Self-Evolving Agent Harnesses via Gated Semantic Quality-Diversity

Source: arXiv — 2026-07-15

Summary

This paper argues that an LLM agent's real-task performance depends heavily on its harness — the prompts, injected knowledge, runtime control logic, and configuration wrapped around a frozen model — and that improving the harness automatically is a more tractable lever than retraining weights. The authors propose Gated Semantic MAP-Elites (GSME), which strictly separates proposing harness edits (done by an LLM that diagnoses failures and drafts patches) from crediting them (done by deterministic code that owns all sampling, measurement, and statistical significance testing). Patches populate a gated, categorical quality-diversity archive keyed on the (WHERE × WHY) pathology an edit addresses, rather than on the specific task it happened to fix. Tested across seven domains with a frozen open-weight model, the harness is selected on a training set and scored exactly once on a held-out sealed test.

Key Takeaways

• Core design principle: separate proposal from credit assignment. An LLM (the "Evolver") diagnoses failures and designs patches; a deterministic layer independently runs sampling, scoring, and significance testing before any patch is credited.
• The self-evolution loop has three parts: a Task Agent that executes train tasks with the current harness, a Scoring component that returns per-task results and failure signals, and the Evolver that diagnoses WHERE and WHY a failure occurred and proposes a targeted patch.
• Patches are archived in GSME (Gated Semantic MAP-Elites) using a categorical grid keyed on the (WHERE × WHY) pathology class rather than on individual tasks, which is meant to keep the archive organized around generalizable failure modes instead of overfitting to specific test cases.
• Reported results: across seven domains, using a frozen open-weight model, the evolved harnesses produced sealed-test gains of +9 to +15.5 percentage points.
• Those sealed-test gains retained 86-147% of the gains measured on the training set — evidence the improvements generalize to held-out tasks rather than being an artifact of overfitting to the training distribution.
• Because the underlying model weights are never touched, the entire performance gain comes from restructuring the harness (prompts, injected knowledge, control flow, configuration) — a cheaper and more auditable lever than fine-tuning.

Reel Script

Hook An LLM agent can gain double-digit percentage points of accuracy without a single weight update. Not from a bigger model — from rewriting the scaffolding around it. A new paper shows how to do that automatically without the system just gaming its own test set.

Core Concept The paper's bet: most of what makes an agent good or bad isn't the model, it's the harness — the prompts, injected knowledge, control logic, and configuration wrapped around it. So instead of fine-tuning, evolve the harness itself.

The risk with any self-improving system is that it learns to cheat its own scoreboard. The fix here is a strict separation of powers: an LLM ("the Evolver") is only allowed to propose changes — it looks at failures, figures out where and why the agent broke, and drafts a patch. But it never gets to decide whether that patch worked. A separate deterministic layer owns all the sampling, measurement, and statistical significance testing, and only that layer decides if a patch earns a spot in the archive.

Patches get stored in something called Gated Semantic MAP-Elites (GSME) — a "quality-diversity" archive, a concept from evolutionary computation where you keep the best solution for each category of problem rather than just the single best solution overall. Here, the categories are pathology types: WHERE the agent failed and WHY. That keeps the archive organized around generalizable failure patterns instead of piling up patches that only fix one specific training example.

Hands-On The evaluation design is the interesting part. The team tested this across seven different task domains, using one frozen open-weight model throughout — so any gains had to come purely from the harness, not the model. The evolution loop trains on a training set: a Task Agent runs the current harness against train tasks, a Scoring component reports back what failed and how, and the Evolver proposes the next patch based on that signal.

Critically, the harness that gets shipped is selected using only training-set performance — then it's run exactly once against a sealed, held-out test set that the evolution process never saw. That one-shot sealed evaluation is what makes the results trustworthy: there's no way to iterate against the test set and overfit to it.

The results: sealed-test gains of +9 to +15.5 percentage points across the seven domains, and those gains retained 86-147% of what was measured on the training set. That retention number matters more than the raw gain — anything meaningfully below 100% would suggest the harness had partly overfit to training quirks; retention above 100% on some domains means the sealed-test gain sometimes exceeded the training gain, a sign the improvements are genuinely general rather than memorized.

Takeaway If harness edits can produce 9-15.5 points of sealed-test improvement with zero fine-tuning, that's a strong argument for treating prompt/harness engineering as a first-class, automatable optimization target rather than manual trial and error. The separation-of-powers design (LLM proposes, deterministic code judges) is the reusable idea here — it's what makes the gains credible instead of just a well-tuned leaderboard score. Worth reading if you're building any agent harness you plan to iterate on repeatedly.

Discussion

(No questions yet — ask follow-ups via a Claude Code chat session on this repo; answers get appended here.)