Evo$^2$: Evolving the Evolver through Weight-Harness Co-Evolution

Abstract: Self-evolving agents are increasingly used to improve LLM systems without human intervention through either weight updates or harness improvements. Existing approaches typically pursue these directions separately: some methods update model weights using self-generated experience, while others rewrite the harness that defines how an agent uses prompts, tools, context, and execution feedback. However, these approaches overlook the relationship between model weights and the agent harness. To connect these processes and ensure effective and smooth agent self-evolving, we propose Evo$<sup>2$, a framework for weight-harness co-evolution. For harness updates, we design a unified dual-role pipeline that a single policy serves as both a Proposer, which writes harness edits, and a Reflector, which diagnoses their effects and guides revision. For weight updates, harness modifications and their execution outcomes guide the training of both the Proposer and the Reflector. We further develop EvoTIDE, a training pipeline that recovers usable trajectories through edit extraction and prefix continuation, then combines SFT with interleaved GRPO across the two roles. Extensive experiments across three coding benchmarks demonstrate that Evo$<sup>2$ significantly outperforms existing self-evolution methods. It achieves 82.1% on Polyglot and 48.3% on SWE-bench Verified, compared with 62.6% and 41.0% for the strongest baseline, respectively. We also show that the evolved harnesses transfer to different tasks without further evolution and rank first in cross-benchmark evaluations. Our dual-role harness improvement framework is also able to extend to self-evolution with proprietary models, improving a GPT-5-mini agent's performance from 24.4% to 48.3%. These results demonstrate the applicability of the framework Evo$<sup>2$ across domains and its broad transferability across models and tasks.

• The paper introduces Evo, a co- evolutionary framework that integrates self-eval, harness & model policy.
• Evo significantly outperforms baselines on coding tasks with improvements up to 19.5% points, demonstrating better effectiveness and efficiency.
• Email the cost-effectiveness of harness-evolution experience and exposes deployed minimised cost.

Evo addresses a structural limitation in self-evolving agents: model-weight adaptation and agent-harness adaptation are usually treated as separate optimization processes. The paper instead formulates them as a coupled system in which an evolver policy improves the executable harness, while the resulting harness modifications and task outcomes provide training data for improving the evolver. The central claim is that this feedback loop produces a more capable search policy and more effective harnesses than either isolated weight evolution or isolated harness evolution.

Problem formulation and central contribution

An agent harness is treated as an executable program specifying prompts, tool use, context management, control flow, and interaction with a fixed task executor. Evo maintains two mutable objects:

1. The harness, which changes through code-level edits and is evaluated on task performance.
2. The evolver policy, whose weights determine how edits are proposed, interpreted, revised, and transferred across search branches.

The task executor remains fixed during co-evolution. Consequently, performance changes are attributed to modifications of the harness and to improvements in the policy that generates those modifications. This separation is methodologically useful, although it also makes the framework dependent on the assumption that the evaluator provides sufficiently reliable feedback.

The evolver uses a unified policy in two roles. The Proposer generates harness edits, while the Reflector analyzes execution outcomes and determines whether the candidate should be revised, combined with a strategy from another branch, or retained. Both roles share parameters, so experience acquired in one role can alter behavior in the other.

Figure 1: Evo alternates between harness modification and policy-weight updates, with evaluated edits providing training experience for the shared Proposer–Reflector policy.

The paper’s principal conceptual contribution is therefore not merely a search procedure over harnesses. It is a co-evolutionary loop in which the policy that performs search is itself trained on the consequences of its search decisions. A successful harness contributes executable behavior, while its associated edit and evaluation trajectory contributes training evidence about how an evolver should act.

Dual-role harness evolution

Harness evolution is organized as a tree. Each node contains an executable harness and its evaluation records; edges encode the edits applied to obtain child harnesses. A parent is sampled from a maintained pool, and the Proposer performs an autonomous Type A modification. The resulting harness is executed by the fixed task executor. The Reflector then receives the source code, edit diff, task-score change, and relevant execution traces.

The Reflector selects among three actions:

• Revision, issuing a directive for the Proposer to repair or extend the current candidate.
• Crossover, selecting a strategy discovered in another branch and directing the Proposer to adapt it to the current harness.
• Retention, preserving the candidate without another edit.

The distinction between the two Proposer modes is important. In Type A, the policy must identify a useful modification from the parent harness and its evaluation history. In Type B, it must translate an explicit Reflector directive into executable source changes. The former measures autonomous search, whereas the latter measures instruction-following and code-level implementation. Training both modes allows the policy to separate diagnosis from implementation while retaining a shared parameterization.

Crossover searching addresses a common weakness of tree-based self-modification: improvements found in one branch may remain inaccessible to other branches. Evo stores extracted strategies in a library, with each strategy represented by its mechanism, observed effect, and compatibility with the current candidate. The Reflector can select a donor strategy when the candidate’s execution traces expose a relevant weakness. The Type B Proposer then adapts that mechanism rather than copying source text mechanically. This design makes crossover a directed, semantically mediated operation rather than unrestricted program recombination.

Figure 2: Harness evolution combines autonomous edits, execution-based reflection, directed revision, crossover from other branches, and trajectory recovery.

The reward for each role is based primarily on the change in externally evaluated task performance. A Proposer receives the difference between the child and parent harness scores; a Reflector receives the difference between the post-intervention and pre-intervention candidates. Invalid, non-executable, no-op, or malformed edits are penalized. The paper also imposes an evidence condition on Reflector gains: an apparent improvement is credited only when execution traces indicate that the added mechanism actually ran. This reduces, but does not eliminate, the possibility of spurious attribution from noisy or underspecified evaluations.

EvoTIDE and trajectory recovery

EvoTIDE—Tree-guided Interleaved Dual-role Evolution—converts harness-evolution traces into training data for the shared policy. The training pipeline has three stages: trajectory collection, SFT initialization, and interleaved GRPO.

A practical difficulty is that model rollouts frequently contain useful partial behavior without producing a formally valid edit. Evo therefore uses two recovery mechanisms. Edit extraction searches incomplete responses for concrete file modifications and converts them into the required action representation. Prefix continuation truncates a rollout after the last successfully applied edit, restores the corresponding intermediate harness, and resumes generation from that prefix when a later edit is malformed or invalid. Recovered candidates still undergo application, startup, and task-evaluation checks.

These procedures increase data yield, but they introduce a potential distributional issue: recovered trajectories are not necessarily sampled from the same process as fully valid trajectories. The paper treats recovery primarily as a way to preserve useful supervision rather than explicitly quantifying its effect on policy bias or optimization stability.

The initial policy is trained with SFT on successful autonomous edits, directed edits, and Reflector outputs selected using downstream evaluation results. Online training then uses GRPO separately for Proposer and Reflector groups. A frozen snapshot of the policy supplies counterpart behavior within each training round: during Proposer optimization, it generates the Reflector directives; during Reflector optimization, it implements sampled directives. This avoids allowing both sides of a single training comparison to change simultaneously.

Parent sampling is designed to expose the policy to both strong and weak harnesses. The pool preserves the root, retains nodes at multiple depths, reserves capacity for high-performing candidates, and samples additional executable candidates using a score-dependent weighting scheme that favors both low- and high-performing harnesses. The intended effect is to train two complementary capabilities: incremental improvement of strong harnesses and repair of weak ones.

The use of a single policy for both roles creates an explicit coupling between diagnosis and implementation. An improved Proposer supplies better candidate modifications for Reflector training; an improved Reflector supplies better directives for Proposer training. The paper’s claim is therefore stronger than that of conventional self-training from successful outputs: the policy is trained on a structured interaction in which edit generation, evaluation, diagnosis, and revision are mutually dependent.

Coding benchmark results

Evo is evaluated with Qwen3.8-27B as both the fixed task executor and, in the main setting, the evolver. It is compared with SICA, DGM, HGM, and GEA on Polyglot, SWE-bench Verified, and LiveCodeBench.

Method	Polyglot pass@1	SWE-bench Verified resolved	LiveCodeBench pass@1
SICA	60.2	20.5	39.0
DGM	60.2	30.0	54.0
HGM	61.8	41.0	56.0
GEA	62.6	25.0	49.0
Evo	82.1	48.3	58.0

Evo improves Polyglot performance by 19.5 percentage points over the strongest baseline, GEA, and improves SWE-bench Verified by 7.3 points over HGM. On LiveCodeBench, the gain is smaller but remains positive: 58.0% versus 56.0% for HGM. The consistency across all three benchmarks supports the paper’s claim that the method is not narrowly optimized for one coding distribution.

The Polyglot result is particularly large and suggests that Evo discovers harness mechanisms that materially alter the executor’s ability to solve tasks. However, the benchmark-level comparison conflates several factors: tree search, crossover, dual-role prompting, trajectory recovery, and weight evolution are all present in the full system. The subsequent ablation is therefore essential for determining whether the gains arise from co-evolution rather than from harness search alone.

Transfer across coding tasks

The paper evaluates each benchmark-selected harness on the other two coding benchmarks without further evolution. Evo achieves the best result in five of six transfer directions.

Source benchmark	Target benchmark	Evo	Best baseline
Polyglot	SWE-bench Verified	21.0	20.0
Polyglot	LiveCodeBench	44.0	45.0
SWE-bench Verified	Polyglot	72.4	69.9
SWE-bench Verified	LiveCodeBench	53.0	50.0
LiveCodeBench	Polyglot	74.0	63.4
LiveCodeBench	SWE-bench Verified	43.0	29.0

The largest transfer advantage occurs when the harness evolved on LiveCodeBench is evaluated on SWE-bench Verified: Evo reaches 43.0%, compared with 29.0% for the strongest baseline. The LiveCodeBench-to-Polyglot transfer advantage is also substantial, at 10.6 points over the best baseline. These results imply that the evolved harnesses contain mechanisms that are not restricted to the source benchmark’s task distribution.

The one exception is Polyglot-to-LiveCodeBench, where Evo reaches 44.0%, one point below the best baseline. Thus, the claim of broad transferability should be interpreted as a strong majority result rather than universal dominance. Transfer also depends on the compatibility of the harness’s prompts, tools, and control flow with the target executor and benchmark.

Fixed-weight proprietary-model experiments

The dual-role harness-improvement procedure is also tested without weight evolution. GPT-5-mini and Claude Haiku 4.5 serve simultaneously as executor, Proposer, and Reflector, with their parameters fixed. This isolates the contribution of harness search, reflection, and crossover from EvoTIDE.

Method	GPT-5-mini	Claude Haiku 4.5
SICA	24.4	42.2
DGM	23.9	43.3
HGM	24.3	45.0
GEA	19.4	44.4
Evo	48.3	47.8

On GPT-5-mini, Evo nearly doubles the strongest baseline, increasing the resolved rate from 24.4% to 48.3%. On Claude Haiku 4.5, the improvement is smaller but still positive, reaching 47.8% compared with 45.0% for HGM. The GPT-5-mini result is important because it demonstrates that the dual-role harness mechanism can produce large gains even when the evolver cannot be fine-tuned.

There is, however, an evaluation asymmetry: Evo reports the better of its two top-ranked harnesses, whereas each baseline reports its top-ranked harness. The experiments average across three independent searches, but this selection rule should be considered when interpreting the magnitude of the proprietary-model comparison.

Generalization to memory tasks

Evo is instantiated on memory tasks by adapting the editable harness and evaluator while retaining the Proposer–Reflector interaction, crossover search, and training procedure. The harness is evolved on LoCoMo and evaluated both on held-out LoCoMo conversations and on LongMemEval-S without further evolution or selection.

Method	LoCoMo F1	LongMemEval-S accuracy
SICA	54.6	59.7
DGM	55.8	60.3
HGM	56.2	64.4
GEA	53.2	48.9
Evo	60.4	71.5

Evo exceeds HGM by 4.2 points on LoCoMo and by 7.1 points on LongMemEval-S. The cross-benchmark result is especially relevant because LongMemEval-S is not used for evolution or selection. The reported Evo searches range from 67.9% to 73.9% on LongMemEval-S, indicating that the result is not attributable to a single anomalous run.

The memory experiments support a domain-general interpretation of the framework, but they do not establish that the same evolved harness is domain-independent. The harness is adapted to memory tasks, and the evaluator, retriever, and task interface differ from the coding setting. The evidence therefore supports portability of the co-evolution procedure across domains, not direct transfer of coding harnesses to memory workloads.

Ablation of weight evolution and efficiency

The weight-evolution ablation fixes the search procedure, executor, and parent harnesses while comparing the base Qwen3.8-27B evolver with the EvoTIDE-trained policy.

Benchmark	Untrained evolver	Trained evolver	Improvement
Polyglot	61.8	78.0	+16.3
SWE-bench Verified	46.0	51.0	+5.0
LoCoMo	47.2	56.5	+9.3
LongMemEval-S	57.1	67.7	+10.6

Training improves the selected champion on every benchmark. The Polyglot improvement is statistically reported as significant, with a 16.3-point gain and $P=.001$. The SWE-bench gain is only 5.0 points and has $P=.086$, so the paper’s evidence for a reliable improvement on that benchmark is weaker. The LoCoMo and LongMemEval-S gains further suggest that the trained evolver learns transferable editing and reflection behavior rather than only benchmark-specific code modifications.

The paper also reports that crossover contributes an additional 4.1 points on Polyglot. This supports the claim that branch-to-branch strategy transfer is not redundant with local revision, although the available results do not fully disentangle crossover from the other components of the search process.

A further claim is that Evo improves performance without increasing inference cost at deployment. On LiveCodeBench, the Evo harness uses approximately 3.6K completion tokens and 10.2 LLM calls per task, compared with 6.6K–6.9K tokens and 26–37 calls for HGM and DGM. Evo therefore achieves the highest reported accuracy while using substantially fewer executor calls. On Polyglot, its champion uses 36 calls and 3.6K tokens, compared with 43 calls and 4.0K tokens for the unevolved harness. The implication is that harness evolution changes the allocation and sequencing of inference rather than simply increasing deliberation.

These efficiency comparisons concern the deployed evolved harness, not the cost of evolution itself. Evo may require considerable search-time evaluation, model inference, SFT, and GRPO computation. Thus, the result establishes improved task-time efficiency, while the total amortized cost of producing the harness remains an open empirical quantity.

Limitations and open questions

The evaluation relies heavily on benchmark execution scores as rewards. This is appropriate for coding and memory tasks with external evaluators, but it leaves Evo exposed to evaluator noise, incomplete test coverage, and reward hacking. The paper penalizes invalid edits and requires execution evidence for some Reflector rewards, yet it does not establish that the learned policy reliably distinguishes genuine functional improvement from benchmark-specific exploitation.

The fixed-executor assumption also limits the interpretation of co-evolution. It permits clean attribution of performance changes to harness edits, but real deployments may involve changing model versions, tools, repositories, or execution environments. It remains unclear whether strategies learned under a fixed executor remain stable when the executor or tool interface changes.

The main comparisons do not isolate every design choice. The reported advantage of full Evo reflects the combined effects of shared-role training, tree maintenance, parent sampling, trajectory recovery, GRPO, and crossover. The ablation establishes a contribution from weight evolution and reports a crossover gain, but a more complete factorial analysis would be needed to quantify interactions among these components.

Finally, the Reflector’s textual diagnosis is treated as useful supervision, although language-model explanations are not necessarily faithful descriptions of the causal mechanism behind a performance change. The evidence-based reward condition partially addresses this issue, but the question of whether the Reflector learns causal program diagnosis or merely correlational heuristics remains unresolved.

Conclusion

Evo presents a unified framework for co-evolving an agent harness and the policy that modifies it. Its Proposer–Reflector architecture combines autonomous editing, execution-based diagnosis, directed revision, and cross-branch strategy transfer. EvoTIDE then trains the shared policy using recovered trajectories, SFT, and interleaved GRPO over a dynamically maintained harness tree.

The empirical results support the central design: Evo reaches 82.1% on Polyglot, 48.3% on SWE-bench Verified, and 58.0% on LiveCodeBench, transfers effectively across coding benchmarks, improves fixed-weight proprietary agents, and extends to memory tasks. Weight evolution contributes substantial gains, particularly on Polyglot and LongMemEval-S, while deployment-time inference costs are lower than those of several baselines. The remaining questions concern evaluator robustness, evolution cost, executor dependence, and the causal validity of Reflector feedback.