The harness is the other half of the agent
There are two ways to make an AI agent smarter: change the model, or change everything around the model. Retraining weights is expensive, slow, and for most teams simply out of reach. But the harness — the prompts, tools, retries, memory, skills and scaffolding that wrap the model — is software you control. That's the quiet thesis behind Harness², a recursive agent harnessing framework published October 9, 2026 by nine researchers at Google Cloud AI Research and Northwestern University, led by first author Ruiyao Xu.
The paper's title — 'Harness²: Recursive Agent Harnessing for an Open World' — names both the method and the ambition. Harnessing is the process of optimizing everything around a frozen model; the squared part is the recursion. And the results are the kind that make you reread them: a single refinement step improved GLM-5 and Gemini 3.5 Flash over their base harnesses by up to 11.5 points on WorkBuddy-Bench, 4.5 points on JobBench, and 11.8 percentage points on LAB — with zero parameters trained. The framework is open source under Apache 2.0, version 0.1.0, installable with uv on Linux.
This is a team story told through a paper and its coverage, not an interview — so what follows is the work itself: what the researchers built, why they built it that way, and what the numbers actually say.
Why self-improvement breaks in the open world
The paper starts from a seductive idea with a bad track record: recursive self-improvement, an agent iteratively rewriting its own scaffolding so it gets better the more it works. In the lab, it works. In the open world — the stream of novel, unseen tasks where real agents actually operate — the authors identify two reasons it falls apart.
First, there is no ground-truth verifier. Real tasks are unseen at design time and novel at test time, so no oracle can tell you whether a harness edit helped. Most self-improvement methods quietly assume labels or test cases exist; online self-improvement without them can happily optimize itself into nonsense. Second, the process doesn't generalize. Most recursive self-improvement is painfully task-specific: tune the harness for task A, learn nothing transferable for task B, start over.
These two problems are why the field has been stuck between offline optimizers — which search over harness code with fixed training splits and verifiers, then go static at test time — and online methods that either discard experience between tasks or inherit a task-specific harness that breaks when the distribution shifts. Harness² is the researchers' answer to both at once, and the answer has two levels.
Propose, Probe, Compose
The first level is task-level recursion: refining the current task's harness through a contrastive Propose–Probe–Compose step that needs no ground-truth verifier at all. Here's how a step works. The agent runs the task once with the base harness as a reference. Then an editor proposes two candidate harness edits: an invariant candidate targeting general agent failures like planning or tool use, and a domain candidate targeting the knowledge and procedures of the current domain. Both candidates run on the same task. Finally, a composer compares the candidates' trajectories against the reference and keeps only the edits backed by observed behavior.
The genuinely clever bit, as one commentator put it, is answering 'how do you know an edit helped when there's no answer key?' by comparison instead of absolute scoring. Contrastive probing sidesteps the missing verifier entirely — you don't need to know the right answer if you can reliably tell which attempt behaved better. The step can be scaled with a recursion budget k: parallel mode probes k invariant and k domain candidates then makes k compositions, sequential mode chains k refinement steps, and performance keeps climbing as you spend more budget.
The harness itself is concrete, not abstract: eight editable components, each mounted as a file — system prompt, guardrails, memory, tool guidance, subagents, skills, scripts, and plugins (middleware) — extending an earlier seven-file split from Agentic Harness Engineering work by one component. The executors in the experiments are OpenCode and Codex, with Claude Opus 4.8 as the default editor, and model-backed runs go through Vertex AI.
The ²: lessons that carry across tasks
The second level is where the 'squared' comes from. Harnessing-level recursion happens after each task: a reflector stores the adopted harness plus an EXPERIENCE.md file of lessons into a library, and that library guides future proposals. Each new task still starts from the base harness — nothing task-specific leaks across — but the improvement process itself gets smarter. Lessons learned on one task make the agent better at future, never-seen tasks.
This is the part that answers the generalization problem. Task-level recursion makes the current task's harness better; harnessing-level recursion makes the harnessing process better. It's recursion on the task, and recursion on the improvement loop itself. And it's plug-and-play: Harness² sits on top of an existing agent harness rather than replacing it, which matters enormously for adoption — teams don't have to throw out their scaffolding to try it.
The design also draws a clean line from the team's earlier work. Where their previous projects — ReasoningBank, SkillOS, HyperSkill — retrieved text memories or curated skills, Harness² rewrites the entire executable runtime. The trajectory of the research program is visible: from remembering, to skilling, to rewriting the machine itself.
The numbers, and the caveats
Across three professional benchmarks — WorkBuddy-Bench, JobBench, and Harvey's LAB — and four model-harness configurations, a single step of Harness² consistently beat the base harnesses with frozen weights. The headline numbers, as means over three runs: GLM-5 under OpenCode rose from 64.2 to 75.7 on WorkBuddy-Bench (+11.5 points); Gemini 3.5 Flash under OpenCode went 72.4 to 77.5; on JobBench the gains ran to +4.5; on LAB partial, GLM-5 under OpenCode jumped 59.6 to 71.4 (+11.8 percentage points). Weaker executors gained more — after one step, GLM-5 beat the base Gemini 3.5 Flash on WorkBuddy-Bench, the adapted weaker model surpassing the unadapted stronger one. Scaling parallel recursion to k=5 lifted Gemini under OpenCode to 80.8 on WorkBuddy-Bench, and on JobBench to 39.0 from a 31.5 base. As a bonus, three of four setups also used fewer steps per task — Gemini under OpenCode fell from 25.4 to 21.9 on WorkBuddy-Bench.
The honest caveats come from the coverage, and they're worth stating plainly. Multi-candidate probing multiplies test-time token costs — every candidate is a real run, so the budget k is also a bill. And the main experiments rely on a frontier editor model, Claude Opus 4.8, doing the proposing; the gains are real, but they're partly bought with a strong editor's judgment. The comparison table also notes that rival methods didn't report these benchmarks themselves, so the head-to-head numbers are the paper's own measurements.
Still, the direction of travel is hard to argue with. If your agents run in production, the layer you can actually change is the harness — and this team just showed, with numbers, how much performance is sitting in it. The code is at github.com/google-research/harness2, the paper at arXiv:2610.14224, and the project page at harness2.github.io. For a field obsessed with bigger models, nine researchers just made a compelling case for better scaffolding.
The playbook
- Optimize the layer you can actually change — The harness — prompts, tools, memory, skills, guardrails, orchestration — is software your team controls. Harness² bets the untapped performance lives there, not in bigger weights.
- Replace the verifier with a comparison — With no answer key at test time, Harness² compares candidate edits against each other instead of scoring them absolutely. Behavioral contrast replaces the verifier.
- Split the editor's attention in two — The editor proposes two candidates per task: an invariant one targeting general failures like planning or tool use, and a domain one targeting knowledge and procedures. Two lenses, one decision.
- Write down what you learned — in a file — After each task, a reflector stores the adopted harness plus an EXPERIENCE.md of lessons into a library that guides future edits. Accumulated experience is a file, not a feeling.
- Scale the search budget, not the model — The recursion budget k scales the search: parallel or sequential, more candidates, more compositions. GLM-5 went from 64.2 to 75.7 at k=1 and kept climbing. Compute is the dial, not the model.