One Recipe, Many Harnesses: What Self-Evolution Encodes Across Languages and Models

Abstract: Self-evolving harnesses are closed-loop systems in which an agent inspects its own rollouts and edits its prompts, tools, and memory. They reliably improve coding agents in evaluations, but prior work reports aggregate gains rather than analyzing what the evolved artifacts encode. It therefore remains unclear whether they encode benchmark-specific adaptations, language-specific engineering knowledge, or compensation for limitations of the underlying model. We disentangle these factors by holding an evolution recipe fixed across a grid of eight programming languages (Multi-SWE-Bench) and three base models, and analyzing the resulting harnesses. The recipe routes every edit through a typed failure signal and records it as a falsifiable contract, making each modification attributable after evolution. Four findings emerge. (1)The loop improves held-out solve rates over both a minimal seed and the manually designed mini-SWE-agent scaffold in most cells, but with two null regions. (2)Gains compensate recoverable execution defects, where defect mass is near zero, and gain is near zero; which defect dominates is cell-specific. A harness closes the gap between what a policy can do and what it does. (3)Evolved harnesses share an abstract playbook across languages but instantiate it with almost disjoint language ecosystem machinery. (4)The shared core transfers and can be distilled into one universal harness, while an ecosystem margin resists both and requires native re-evolution. Together, these results recast the evolved harness as a legible compensation layer, shaped jointly by the language's engineering demands and the model's behavioral gaps, rather than an opaque benchmark-tuned scaffold.

• The paper shows that TRIAGE improves held-out coding-agent performance in most language-model cells by diagnosing failures and evolving prompts, hooks, memory, and tools under a non-regression gate.
• The paper finds that 88% of 256 recovered instances involved detector-covered execution defects, with gains reflecting compensation for behaviors the base model could already perform rather than new capabilities.
• The paper demonstrates that evolved harnesses share a portable disciplinary core but retain 20–40% ecosystem-specific content, making native re-evolution more effective than universal distillation or cross-language transplantation for complex targets.

Overview

This paper asks what a self-evolving coding-agent harness actually encodes. Self-evolving harnesses—outer loops in which an agent inspects its own rollouts and edits its prompts, tools, and memory—have been shown to improve solve rates on repository-level software engineering benchmarks, but prior evaluations report only aggregate gains. Whether those gains reflect benchmark overfitting, language-specific engineering knowledge, or compensation for base-model behavioral gaps has remained unresolved. The authors disentangle these factors by holding a single evolution recipe, TRIAGE (Typed Routing and Instrumented Attribution for Guided Evolution), fixed across an $8 \times 3$ grid of programming languages (Multi-SWE-Bench subsets) and rollout models (Claude Haiku 4.5, GPT-5-mini, DeepSeek-V4-Flash), then analyzing the resulting artifacts structurally and behaviorally.

The central conclusion is that the evolved harness is best understood as a legible compensation layer: it closes the gap between what a frozen policy can do and what it does under a bare scaffold, without raising the policy's capability ceiling. The language determines which disciplines a task demands; the model determines how many of them the base policy already supplies; evolution installs the difference.

The TRIAGE recipe

TRIAGE builds on AHE's observability-driven backbone (Lin et al., 28 Apr 2026) and exposes four versioned harness slots: system prompt, workflow hooks, lessons memory, and tool implementations, implemented as a plugin layer over mini-SWE-agent. Every setting starts from an identical minimal seed—a short prompt, one shell tool, empty hooks and memory—so any rule appearing in an evolved harness must have been derived from observed rollouts rather than inherited.

Two mechanisms distinguish TRIAGE from unstructured reflection-based self-improvement. First, instrumented attribution: each failed rollout receives layered evidence combining verifier-side records (stage-level execution traces that expose, e.g., interference between a submitted patch and the hidden gold test patch) and budget-side records (termination reasons, resource use). Second, typed routing: a deterministic bucketing schema assigns each failure to a class such as patch_broke_tests, no_build, or wrong_fix, and routes the diagnosis as an advisory dossier to the evolve agent, which must emit a falsifiable change manifest committing to predicted task-level fixes and regressions before the next round validates them. Selection uses a non-regression gate ($\tilde{s}_r = s_r - 2.0\,\rho_r$) so that rounds cannot trade previously solved instances for aggregate gains, and the shipped checkpoint is floored at the seed. Memory is capacity-bounded (12 entries, 400 characters) with instance-specific tokens rejected, forcing distillation rather than accumulation.

Across all diagnosed rollouts in the grid, wrong_fix is the largest bucket at 38.7%—failures the loop deliberately does not route—and model_incompat is vanishingly rare (1.0%), explaining why no cell ever evolved middleware.

Effectiveness and its two null regions

Under identical step, cost, and rollout budgets, the evolved harness improves held-out mean_solve@3 over the minimal seed in most cells and matches or exceeds mini-SWE-agent in 14 of 24 cells. On Claude Haiku 4.5, the strict ordering evolved > mini-SWE-agent > seed holds on every non-Python language, with large paired effects: Java +80.0 points ($z = 11.66$), C++ +74.3 ($z = 10.30$), Rust +61.1 ($z = 6.80$). All non-Python Haiku cells reach significance at $p < 0.01$.

Two null regions fall along the grid's axes. Python shows approximately zero gain under all three models; its detector-covered defect rate (5.6%) is the lowest of the eight languages, meaning the disciplines the loop would install are ones these policies already follow. GPT-5-mini gains little anywhere ($|z| < 1.3$ in every cell); its detectors fire seldom, and its evolved memory contains no test-file rule at all—on languages where every other model's harness installs one first. Notably, GPT-5-mini is the weakest model under mini-swe-agent despite being a frontier model, which the authors read as evidence that models possess qualitative properties independent of quantitative capability level.

Mechanism: compensation of recoverable execution defects

The failures the loop repairs are predominantly process defects rather than comprehension failures: editing test files so they collide with the hidden gold patch, shipping non-compiling source, submitting without running the target test. Of 256 recovered held-out instances, 88% carried a detector-covered defect under the seed (81% test-file edits, 7% build breaks). For Haiku and DeepSeek, 95% and 91% of recoveries respectively are attributable to such self-inflicted defects. Seed defect mass correlates strongly with net gain across cells ($r = 0.81$ pooled), though conversion rates differ by model (0.58 for Haiku, 0.34 for DeepSeek, 0.12 for GPT-5-mini).

Which defect dominates is cell-specific: non-compiling changes account for 70% of C++ rollout defects but under 10% of Go's. This is the operational argument for per-cell evolution—a static scaffold hard-codes one guess for all cells, whereas the binding defect varies systematically with the ecosystem. The authors are careful about scope: detectors cover only part of the recoverable space, and no recovered instance shows the harness enabling a repair the base policy could not otherwise express—the gain is compensation, not capability extension.

A planted-defect probe bounds this account further. When the authors inject a controlled environment gate whose remedy is a specific operational fact discoverable only by running once and reading the error, the loop fails to converge on it (held-out scores move within noise, both conditions non-positive), instead writing generic verification discipline. The loop exhibits recall of recurring failure modes but no evidence of discovery of novel environment-specific knowledge.

Cell-specificity: shared playbook, disjoint instantiation

Coding each evolved harness into abstract concepts and concrete ecosystem markers reveals a two-level structure. Mean off-diagonal Jaccard overlap at the concept level is 0.55 (Haiku) and 0.57 (DeepSeek)—a substantial shared disciplinary core—while overlap at the ecosystem-marker level falls roughly fourfold to 0.12 and 0.14. Every evolved harness is 20–40% ecosystem-specific (means 26% and 29%). The same discipline appears redundantly across slots within a single harness: as a prompt rule, a memory lesson, and a state-dependent hook firing at submission time. Because both measurement biases (LLM rubric granularity, lexical marker extraction) push the two levels toward each other, the reported gap is if anything understated.

An ablation on the (Go, DeepSeek-V4-Flash) cell shows this loop is not driven by meta-agent capability: an ultra-weak open-weights 20B driver (GPT-OSS-20B) achieves held-out performance statistically indistinguishable from Claude Sonnet 4.6 (34.2 vs. 35.6 vs. 33.3), indicating that typed diagnostic routing, not external knowledge injection, governs the gains. A second ablation finds pre-installed capability tools net-negative (−12.9 pp relative to evolving without one), suggesting the loop's near-total avoidance of tool edits reflects their low marginal value against behavioral rules rather than unreachable machinery.

Bounded portability

Three independent measurements triangulate how far evolved harnesses transfer. Textual analysis locates 20–40% of content in ecosystem-specific machinery. Distillation into a single language-agnostic, memory-only universal harness recovers retention $\rho = (u-m)/(n-m)$ of 1.08 (Go) and 1.13 (JavaScript)—statistically indistinguishable from native—but only 0.68 (Java), 0.65 (C++), and 0.48 (TypeScript) on ecosystem-heavy targets. Transplantation of foreign harnesses yields positive retention in 18 of 20 ordered pairs (mean 0.63), yet falls below native in 14 of 20, with full recovery in only 6.

The two reuse strategies bracket the native ceiling from opposite sides: on ecosystem-heavy targets, transplants beat the universal harness (C++ 0.90 vs. 0.65) but still trail native, giving universal ≤ transplant < native; on generic targets the order reverses. Export and import are nearly uncorrelated marginals—JavaScript exports well into typed targets but is the least recoverable target (column mean 0.20). The single strongly negative cell, JS→TS (−2.30), identifies precisely where transfer fails: TypeScript test runners transpile without type-checking, so compile verification is not a free consequence of running tests and must be named explicitly in the harness. The boundary portable harnesses cannot cross is thus not interpreted-versus-typed per se, but the point at which a discipline stops being enforced for free by the ecosystem's execution chain.

Limitations

The paper concedes several constraints plainly. Evidence comes entirely from single-goal, single-episode repair tasks; persistent within-episode memory and sub-agent decomposition are correspondingly untested, and transfer to longer horizons remains open. What counts as "recoverable" is partly defined by SWE-Bench-style grading (the hidden gold test patch convention makes test-file edits fatal), so absolute gains partly reflect protocol learning, though cross-harness comparisons hold the protocol fixed. No head-to-head comparison with related methods (AHE, HarnessFix) or compute-matched inference-time baselines was run—the latter being the most informative gap, since the paper shows the harness beats a fixed scaffold at equal inference cost, not that evolution is the best use of a fixed total budget. Component-level attribution is limited: diagnostic routing, contracts, the non-regression gate, and two-axis editing are evaluated only as a bundle. Finally, splits are small (20/50 instances per language), evolution runs once per cell (so run-to-run variance is folded into cross-language differences, making cell-specificity a lower bound on agreement), and the loop performs three rounds of greedy hill-climbing rather than population search, so reported harnesses are reachable improvements, not optima.

Conclusion

By holding one instrumented evolution recipe fixed across eight languages and three models, this paper converts self-evolving harnesses from opaque scaffolds into analyzable artifacts. The gains are compensations of recoverable execution defects whose composition is cell-specific; evolved harnesses share a disciplinary playbook while instantiating it through almost disjoint ecosystem machinery; and the portable core survives transplantation and distillation but leaves an ecosystem margin of roughly a third of native gain that neither reuse strategy recovers. The practical guidance is concrete: a base policy's measured defect profile is a cheap leading indicator of where harness engineering pays off, existing harnesses are useful bootstrapping assets, but native re-evolution remains necessary for complex ecosystems.