Evo-Harness: Context-to-Harness Skill Compilation for Self-Evolving Agents

Abstract: Learning from experience is critical for developing capable, self-improving LLM agents. Existing methods typically extract knowledge from accumulated trajectories via reflection, memory, rules, or skills. However, agents in realistic environments continuously encounter novel tasks, often offering only a one-shot opportunity to improve. These executions yield rich but highly noisy contexts, entangling broadly useful lessons with task-specific artifacts. Critically, prior works rarely validate their effectiveness on complex real-world tasks or isolate the underlying drivers of improvement. To address these gaps, we formulate online harness learning, where a frozen agent improves by continually updating a structured harness across sequential tasks. This formulation enables a systematic study of key self-improvement factors through our proposed Evo-Harness. At its core, context-to-harness skill compilation distills noisy, single-shot executions into reusable skill harnesses for cross-domain and topic-level adaptation. To demonstrate the efficacy of one-shot skill compilation, we evaluate across five realistic benchmarks (TerminalBench2, SWE-bench, CL-Bench, -bench, WebArena-Infinity). Our extensive analysis demonstrates the effectiveness of Evo-Harness and provides a principled understanding of how LLM agents can effectively learn on the fly. Our code is available at https://github.com/A-EVO-Lab/a-evolve/tree/release/evo-harness.

• The paper introduces online harness learning, where a frozen LLM solver incrementally updates external general and topic skills from failed task trajectories using Add, Merge, Revise, or Skip edits.
• Evo-Harness achieves the highest success rate on all five benchmarks, including 73.03% on TerminalBench-2—10.1 points above No-Evolve—and improves procedural task performance most consistently.
• The study shows that grounded feedback and solver capability are critical: self-judgment can harm results, stronger models benefit more, and evolved guidance may reduce performance for weaker solvers.

Evo-Harness addresses a specific gap in self-improving LLM agent research: most experience-based methods mine accumulated trajectories offline, whereas realistic deployments present tasks sequentially, each offering only a one-shot opportunity to improve. The paper formulates online harness learning, in which a frozen solver improves by incrementally updating an external, structured harness, and instantiates it as Evo-Harness via context-to-harness skill compilation. The framework is evaluated on five realistic benchmarks and doubles as a controlled instrument for isolating which factors—evolver design, feedback grounding, transfer settings—actually drive improvement.

Problem formulation

The setting is a stream of task batches $\{B_1,\ldots,B_K\}$. Before each batch, the agent holds a harness $\mathcal{H}_i$, a compact set of guidance entries external to the frozen solver. For each task, a bounded selection of entries ($|\mathcal{S}_{i,j}| \le b$) is injected into the task context; the solver executes and produces a context $c_{i,j}$ comprising the instruction, action trajectory, outcome, and any available feedback (verifier results, unit-test outputs, tool diagnostics). The harness is then updated from these contexts while solver parameters remain fixed.

Two design choices distinguish this from passive memory stores. First, reflection is triggered only on failures or negative feedback, on the argument that failures expose the solver's current boundary (incorrect assumptions, missing constraints, weak verification) while successful executions mostly carry task-specific noise. Second, candidate memories are not appended directly; an evolver compiles them into edits of type Add, Merge, Revise, or Skip against the existing harness. The evolved harness has two levels: general skills capturing cross-task patterns and topic skills preserving localized procedures for recurring task formats or domains. Batch-level updates enable cross-task comparison, and the formulation reduces to per-task updating when batch size is one.

Main results

With Claude Opus 4.6 as solver, Evo-Harness achieves the best success rate on all five benchmarks:

Method	CL-Bench	TerminalBench-2	SWE-bench Lite	τ-bench	WebArena-Inf.
No Evolve	29.54	62.92	63.67	72.73	72.50
AWM	28.91	62.92	62.67	70.91	70.00
DC-Cu	29.23	60.67	63.00	72.12	71.25
Evo-Memory	29.38	64.04	64.00	72.12	72.50
ACE	29.70	61.80	63.67	72.73	71.25
XSkill	31.44	66.29	64.67	73.94	73.75
Evo-Harness	34.02	73.03	67.00	76.97	76.25

The largest gain is on TerminalBench-2 (+10.1 over No-Evolve), which the authors attribute to tasks exposing reusable procedural structure. Notably, several baselines underperform No-Evolve on some benchmarks, supporting the paper's claim that retrieved or evolved guidance can be noisy, overly specific, or mismatched to the solver—experience reuse is not automatically beneficial.

Category-level and model generality

On CL-Bench across five solvers, Evo-Harness improves overall scores for every model, but gains scale with solver capability: +3.7/+4.5/+3.8 for Opus 4.7/4.6/4.5 versus only +1.1 for Kimi-K2.5 and +0.8 for GPT-OSS. This implies stronger solvers are better able to interpret and apply evolved guidance—an important boundary condition on the method's applicability. By category, Procedural Task Execution shows the most consistent improvements (Opus 4.6 and 4.5 each gain +9.8), while Empirical Discovery Simulation is unstable, including drops of −2.5 for Opus 4.6 and −1.0 for GPT-OSS, suggesting exploratory tasks are sensitive to overly specific guidance.

Harness content and component ablations

Analysis of evolved skill distributions shows benchmark-specific adaptation rather than generic accumulation: WebArena-Infinity yields workflow/procedure skills, TerminalBench-2 emphasizes verification and recovery, τ-bench mixes tool/API operation with domain reasoning. Ablations show both harness levels contribute but their relative value is task-dependent: on CL-Bench, Topic Only reaches 33.70 (near the full 34.02) while General Only drops to 30.28; on SWE-bench Lite the pattern reverses, with General Only at 66.67 versus Topic Only at 64.33. Removing solver-side proposal ("No Propose") still improves over No-Evolve but stays below the full method, indicating proposal and harness-level compilation are complementary.

Transfer and solver–evolver pairing

Three update settings were compared on SWE-bench Lite: No-Evolve (68.8), Train-Split Transfer using skills evolved by Sonnet 4.5 on the training split and applied by an Opus 4.7 test solver (73.4), and Online-Updated (75.0). Two findings follow. Skills evolved by a smaller model transfer usefully to a stronger solver on unseen tasks, and in-situ updates add a further +1.6 by adapting to the local failure distribution of the test stream.

The solver–evolver pairing analysis yields a more nuanced result. With an Opus 4.7 solver, cross-model evolution (Sonnet as evolver) slightly outperforms same-model evolution (76.0 vs. 75.3). But with a Sonnet 4.5 solver, both Same and Cross configurations fall below No-Evolve (55.3/55.7 vs. 58.0). The authors conclude that harness benefit depends on the base solver's capability: if the solver cannot reliably follow or contextualize injected guidance, evolution can actively hurt performance—a plainly stated negative result.

Feedback grounding

Feedback source and granularity matter substantially. Self-generated feedback, where the LLM judges its own success, underperforms No-Evolve on both benchmarks (CL-Bench 27.96 vs. 29.54; SWE-bench Lite 61.67 vs. 63.67), demonstrating that ungrounded self-judgment introduces misleading harness updates. Environment-grounded signals are reliable: Standard diagnostic feedback is best on CL-Bench (34.02 vs. Minimal's 29.86), but on SWE-bench Lite Minimal pass/fail feedback slightly exceeds Standard (67.33 vs. 67.00), plausibly because detailed error traces encourage over-fitting the harness to task-specific failures. The useful feedback granularity is therefore benchmark-dependent, not universally "more is better."

Limitations and open questions

The paper concedes several boundaries. Evaluation covers single-agent, text-based environments (web, CLI, software engineering, tool use); embodied and multi-agent settings, where coordination changes what a harness must encode, are untested. The harness is instantiated exclusively as natural-language Markdown skill files; executable code skills or structured programs are not studied. The appendix also notes that fail-to-pass case analyses are not single-skill causal ablations—multiple skills may be injected together—and that some benchmarks do not record injected skills in every result file, so the qualitative hotspot analysis contextualizes rather than establishes causality. Open questions include whether the general/topic decomposition remains optimal for other harness media, and how to make evolution reliable for weaker solvers that currently degrade under their own evolved guidance.

Conclusion

Evo-Harness contributes a formalization of online harness learning, a compilation mechanism that converts noisy one-shot execution contexts into structured general and topic-level skills, and a systematic ablation-driven account of what drives frozen-agent self-improvement. Its strongest empirical result is consistent superiority over experience-based baselines across five realistic benchmarks, with TerminalBench-2 showing a ten-point gain. Equally valuable are its negative results: ungrounded self-feedback harms evolution, weak solvers may be hurt by their own harnesses, and baseline experience reuse frequently underperforms doing nothing at all. Together these position the harness as an interpretable object for studying online adaptation rather than merely a performance artifact.