10 Layers of Self-Improving Harness Stack

28 research papers say what should developers build around the model (Harness)

In ~10 mins: the 10-layer stack, the static-harness problem, the evidence behind each layer, and the one caveat that should sit above every self-improving agent demo

Everyone is talking about the new “loop engineering”.

Most developers probably do not need a general agent loop yet.

They need a narrower loop: a self-improving harness, where the system learns by editing the tools, memory, skills, policies, validators, and routing around the model.

Generic loop engineering asks whether the agent should keep running.

AlphaSignal AI@AlphaSignalAI·Jun 9 ArticleMost Developers Do Not Need Agent Loops Yet The patterns were documented in 2024. Here’s who it pays off for, and the four conditions that decide.

In ~9 mins: the four-condition test, what Anthropic documented back in 2024, who loses and why,…152716639K

Self-improving harness engineering asks what the system learned after the run ended.

We reviewed 28 papers in this cluster, then reduced them to one stack. Main papers covered are in the appendix.

The pattern is simple: keep the model stable, make the harness editable, record every run, mine failures, propose bounded changes, gate those changes, version the result, and measure whether the worker agent actually benefits.

This is not “let the agent rewrite itself.”

It is closer to CI (Continuous Integration) for agent behavior.

Context

PS: Every bold text is actually a research paper.

A static harness is the system around the model: prompt, tools, memory rules, context selection, retry logic, validators, permissions, and orchestration.

It can be strong and hand-tuned, but after a failure, it does not learn unless a human patches it.

A self-improving harness turns failure evidence into changes on that system.

The base model can stay frozen while the learning surface becomes external, inspectable, testable, and reversible.

AlphaSignal AI@AlphaSignalAI·May 28 ArticleThe Model Isn’t the Agent AnymoreA UC Berkeley paper argues that long-horizon agent performance now turns on six system components around the model, not just the model itself.

In ~9 mins: the six-component framework, the three…12114.6K

Several papers now report gains from changing the harness while the model stays fixed.

Self-Harness reports held-out Terminal-Bench-2.0 gains from 40.5% to 61.9%, 23.8% to 38.1%, and 42.9% to 57.1% across three models. Agentic Harness Engineering raises Terminal-Bench 2 pass@1 from 69.7% to 77.0% across ten iterations, while the base model stays fixed.

SkillOpt reports the cleanest portable-state result: best or tied on all 52 evaluated model, benchmark, and harness cells. Retrospective Harness Optimization moves SWE-Bench Pro from 59% to 78%, and Natural-Language Agent Harnesses compresses a Live-SWE static harness policy from 60.10k code tokens to 2.90k tokens while scoring 73.0 versus 67.0.

The warning label comes from Harness Updating Is Not Harness Benefit.

That paper finds the harness-updater gap across base tiers is at most 3.1 points, while downstream benefit varies much more by model and benchmark.

So the claim is smaller than “self-improving agents are solved.”

The harness can become a trainable system surface, but only if every change has evidence, a gate, and a rollback path.

The stack has ten layers.

Do not build all ten on day one. The point is to know which layer your agent is missing.

Quick takeaway: start with a stable runtime and trace log, then put learning into external files the team can inspect.

Mine failures into small proposals, gate every change, version the accepted edits, and route specialized variants when one harness starts fighting itself.

Only after that should teams measure worker benefit and consider weight updates.

Layer 1: Stable substrate

The first layer is boring on purpose.

Pick what stays fixed while the harness changes: base model, runtime, tools, task interface, evaluator, permissions, and benchmark split.

If everything moves at once, the system cannot tell what worked.

AHE makes this concrete. It keeps the base model fixed and evolves the surrounding coding-agent harness, lifting Terminal-Bench 2 pass@1 from 69.7% to 77.0%.

AlphaSignal AI@AlphaSignalAI·May 1 ArticleHow to Make a Coding Agent Smarter Without Touching the Model or the PromptA new paper evolves a coding agent’s tools, middleware, and memory automatically. It beats every human-tuned harness in 32 hours.

The system prompt alone regresses. Editing it as the only adaptation…360374130K

Self-Harness uses the same discipline from a different angle. The fixed model proposes bounded edits to its own operating harness, then accepts only edits that do not regress held-in or held-out splits.

Code as Agent Harness gives the broader substrate idea: code is no longer only the thing an agent writes. It is also the executable, inspectable, stateful medium the agent runs through.

AlphaSignal AI@AlphaSignalAI·May 21 ArticleThe Three Harness Layers and How to Audit Your StackA 100-page survey by UIUC, Meta, and Stanford maps the harness layer that runs Claude Code, Codex, and SWE-agent.

Most agent failures aren’t reasoning failures. They’re harness failures. An agent…2105013K

Practical rule: freeze the model and task interface during a harness-evolution run.

Treat every harness change like a diff against a stable baseline.

Layer 2: Trace log

The harness cannot learn from the final answer alone.

It needs the path: tool calls, file reads, retries, verifier outputs, costs, failures, and state changes.

AHE calls this experience observability. Its Agent Debugger turns raw rollouts into per-task analysis reports and a benchmark overview, so the updater reads root causes instead of a pile of traces.

RHO pushes the idea further. It improves SWE-Bench Pro from 59% to 78% by reusing unlabeled past trajectories, then ranking candidate harnesses with self-preference.

Reflexion and ExpeL are earlier versions of the same instinct.

A failed run should leave something behind: a reflection, an experience, an insight, or a trace that changes the next run.

Logging rule: keep the full trajectory and the score.

A score tells the updater that something failed. A trace tells it where to look.

Layer 3: External state

The safest place to put learning is outside the model.

Skills, memory files, natural-language policies, tool wrappers, and reusable procedures can be inspected, copied, tested, and rolled back.

SkillOpt is the cleanest example. It edits one portable skill document, keeps the target model and harness fixed, and accepts the edit only when a held-out selection score improves.

That boundary matters. SkillOpt is not a full harness rewriter, but it is the easiest pattern for developers to adopt today.

Its numbers are hard to ignore: best or tied on 52 of 52 evaluated cells, with GPT-5.5 gains of +23.5 points in direct chat, +24.8 in Codex, and +19.1 in Claude Code.

AlphaSignal AI@AlphaSignalAI·May 26 ArticleThe Third Way to Adapt a Frontier Agent Microsoft just trained an agent’s skill file like neural-network weights, with bounded edits, a held-out gate, and 52-of-52 wins across 6 benchmarks and 3 harnesses.

In ~7 mins: the third way to…294011K

Natural-Language Agent Harnesses makes the same move at the harness-policy level.

It turns high-level harness control into a shorter editable document, then runs it through an Intelligent Harness Runtime. On Live-SWE, the paper reports 60.10k code tokens compressed to 2.90k natural-language harness tokens, with 73.0 versus 67.0 for the code harness.

Trace2Skill shows another version of the layer.

It distills execution traces into a portable skill directory, and reports up to +57.65 absolute points on WikiTableQuestions when skills evolved from Qwen3.5-35B trajectories improve a Qwen3.5-122B agent.

HeavySkill points in the same direction from the reasoning side.

The article’s useful lesson is not the repo path. It is that a repeated reasoning protocol can become a portable skill, rather than staying hidden inside orchestration code.

AlphaSignal AI@AlphaSignalAI·May 7 ArticleHow HeavySkill Turns Agentic Harness Tricks Into a One-File Inner Skill Two-stage protocol from Meituan, R1-Distill-Qwen3-8B goes 35.7% to 69.3% on IFEval

Meituan’s LongCat team argues the heavy-thinking patterns inside Claude Code, Codex, and Kimi K2 are one skill in…10625.5K

Adoption rule: start with one external artifact.

If a team cannot version one skill file or harness policy, it is not ready for a self-improving harness.

Layer 4: Failure mining

Do not send every trace back into the updater.

The harness needs the failures that teach a reusable lesson.

Self-Harness calls this Weakness Mining. Failed records are clustered by verifier cause, causal status, and agent mechanism, then packed into an evidence bundle for proposal.

RHO uses a different filter. It selects a difficulty-diverse coreset of 10 past tasks, runs 3 trajectories per task, and combines self-validation with self-consistency before proposing a harness update.

Trace2Skill splits the work across analyst agents.

One analyst reads one trajectory, explains a local lesson, then a merge step compresses the patches into one skill directory.

AHE does the same at harness scale. It turns raw rollouts into per-task root-cause reports plus a benchmark overview.

Failure-mining rule: mine failures into named classes.

“Improve the agent” is too vague. “Fix repeated verifier failures caused by missing tool-state checks” is a harness update waiting to happen.

Layer 5: Proposal engine

Only now does the agent write a change.

The proposal engine turns evidence into a candidate edit: a prompt rule, a tool wrapper, a memory change, a skill update, a routing policy, or a workflow change.

Meta-Harness shows why the proposer needs more than a score.

Its full-history interface reaches 50.0 on the text-classification ablation, while scores-only reaches 34.6 and scores plus summaries reach 34.9.

The same paper reports +7.7 points while using roughly 4x fewer context tokens on online text classification, plus +4.7 points across five held-out models on retrieval-augmented math.

AHE adds a stricter contract.

Every edit names the changed component, the evidence behind it, the predicted fixes, and the at-risk regressions. The next round checks whether those predictions landed.

HarnessX makes the edit surface typed.

Its AEGIS loop edits harness primitives through typed processors, but its +14.5% average and +44.0% peak gains carry an important caveat: all gains are measured on the same task set used for evolution.

Proposal rule: make each edit small enough to test.

A harness edit without a predicted outcome is just a prettier prompt.

Layer 6: Validation gate

The gate is the product.

Without it, the loop is just an automated way to overfit.

Self-Harness accepts a candidate only when it does not regress held-in or held-out splits and improves at least one of them.

SkillOpt is even cleaner: the candidate skill must score strictly higher than the current skill on the held-out selection split. Ties are rejected.

HUINHB explains why this gate cannot stop at “did the update look useful.”

The paper separates harness-updating from harness-benefit, and shows that updater quality can vary by only 3.1 points while downstream benefit varies much more.

Gate rule: never promote a harness edit without a held-out check, a regression check, or a domain verifier.

No gate, no self-improvement.

Layer 7: Versioning and rollback

A self-improving harness should look more like a repo than a memory blob.

Every change needs a diff, a reason, a score, and a path back.

Autogenesis formalizes this with versioned resources, commit, and rollback.

Prompts, agents, tools, environments, and memory become first-class objects with immutable snapshots and restore operations.

AHE does it through file-level edits, git commits, and manifests that record predicted fixes and predicted regressions.

SkillOpt keeps rejected edits too. Failed edits become negative evidence for the next round, not trash.

Lineage rule: keep the history.

If a future run gets worse, the system should know exactly which harness edit to blame first.

Layer 8: Routing and variants

One harness cannot carry every lesson forever.

As tasks diverge, a single global policy becomes a pile of local fixes.

Adaptive Auto-Harness uses a harness tree and solve-time routing for open-ended task streams.

Each branch carries its own prompt, skills, and tool registry, and a router chooses the branch with a confidence threshold of 0.7.

HarnessX shows the same pressure inside its experiments.

On GAIA with GPT-5.4, the single-harness Global strategy peaks at 73.8% and falls to 49.5%, while Ensemble routing reaches 87.4%.

Voyager is the older intuition in a different domain.

It keeps an executable skill library, retrieves the top 5 relevant skills, and reports 96.5% top-5 retrieval accuracy over 309 samples.

Routing rule: branch before the harness turns contradictory.

Route by task class, difficulty, tool surface, or failure mode.

Layer 9: Benefit measurement

A harness update is not the same thing as a better agent.

HUINHB exists because those two numbers get mixed together.

The paper reports that harness-updater performance is relatively flat across base tiers, with a gap of at most 3.1 points.

But downstream benefit is non-monotonic. On SWE-style tasks, Qwen3-235B gets a 19.3 point benefit, Qwen3-32B gets 4.4 points, and Claude Opus 4.6 gets 2.6 points.

That means the writer of the update is not always the bottleneck.

Sometimes the worker agent cannot load the harness, follow it, or benefit from it over a long run.

Measurement rule: measure the worker with the new harness.

Do not use update quality as a proxy for deployed behavior.

Layer 10: Optional weight update

Weight updates come last.

They are useful when the task needs behavior the harness cannot express, but they make attribution harder.

SIA is the hybrid case.

It combines harness updates with weight updates in one feedback-agent loop.

SIA’s arXiv v2 abstract reports 25.1% over prior SOTA on LawBench, 12.4% faster GPU kernels than prior SOTA, 1,017 versus 1,161 microseconds, and 20.4% over prior SOTA on denoising.

AlphaSignal AI@AlphaSignalAI·Jun 13 ArticleHow SIA’s Self-Improving Loop Works, And How to Actually Run It A Feedback-Agent that rewrites scaffolds and trains LoRA weights, three SOTA results, an MIT repo, and a 10-minute setup

In ~8 mins: the 3-agent loop, the harness-vs-weights ablation across 3…212555.3K

Training rule: do not train weights until the harness loop is measurable.

If traces, gates, rollback, and benefit measurement are missing, weight updates only make the system harder to debug.

AlphaSignal Take

The real shift is not self-improvement as a personality trait.

It is self-improvement as a software loop.

The safest stack starts small: trace logs, one external skill or policy file, a proposal step, and a validation gate.

Then add versioning, routing, and benefit measurement before weight updates.

The strongest papers point in the same direction, but the evidence is not broad enough to trust blindly.

Several results are benchmark-specialized, same-split, or measured inside the task set used for evolution. HarnessX explicitly reports no held-out evaluation.

The line to remember is from HUINHB: harness updating is not harness benefit.

If the worker agent cannot load, follow, or use the new harness, the update is just a nice-looking diff.

So the first question for any self-improving agent demo is not “what changed?”

It is “what gate accepted the change, and did the worker get better after it?”

Follow @AlphaSignalAI for more content like this.

All sources in the first reply. Get the 5-min digest read by 300,000+ AI Developers. (link in bio)

Appendix: main papers covered

• Self-Harness: Harnesses That Improve Themselves (June 2026)

• Meta-Harness: End-to-End Optimization of Model Harnesses (March 2026)

• HarnessX: A Composable, Adaptive, and Evolvable Agent Harness Foundry (June 2026)

• Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses (April 2026)

• Retrospective Harness Optimization: Improving LLM Agents via Self-Preference over Trajectory Rollouts (June 2026)

• Adaptive Auto-Harness: Sustained Self-Improvement for Agentic System Deployment on Open-Ended Task Streams (June 2026)

• SIA: Self Improving AI with Harness & Weight Updates (May 2026)

• Autogenesis: A Self-Evolving Agent Protocol (April 2026)

• Natural-Language Agent Harnesses (March 2026)

• Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents (May 2026)

• SkillOpt: Executive Strategy for Self-Evolving Agent Skills (May 2026)

• Trace2Skill: Distill Trajectory-Local Lessons into Transferable Agent Skills (March 2026)

• Voyager: An Open-Ended Embodied Agent with Large Language Models (May 2023)

+15 others..leave a reply if you want them all.