← Back to blog
AiAbout 6 min read

Improve the Agent Without Touching the Model

Published Nov 3, 2026
Improve the Agent Without Touching the Model

A harness, in the current vocabulary, is everything around the model that lets it act: the system prompt, the tools, the memory, the skills, the orchestration. For two years the way you improved an agent was to improve the model. Harness² asks a different question: what if you leave the weights alone and rewrite the scaffolding, per task, automatically?

Google Research published the paper in October (arXiv 2610.14224) and open-sourced the code under Apache-2.0. The repo has about 22,000 stars. The claim is specific enough to argue with: one recursion step improves GLM-5 and Gemini 3.5 Flash over their base harnesses, with gains of up to 11.5 points on WorkBuddy-Bench, 4.5 points on JobBench, and 11.8 percentage points on LAB's partial pass rate.

No fine-tuning. No new model. The weights are frozen the entire time.

The eight things it is allowed to change

The framework exposes exactly eight editable components, and the list is the clearest statement of what the authors think a harness is:

System prompt, guardrails, memory, tool guidance, subagents, skills, scripts, plugins.

Four of those construct context. Two define the tool interface. One orchestrates delegated work. One controls middleware. If you have built an agent and felt that half your effort went into these eight things and none of it into the model, this repo is a formalization of your job.

The eight-item list also functions as a boundary. Harness² cannot change the model, cannot retrain it, cannot touch its weights. Everything it does is text: rewriting instructions, adding or removing a skill, changing how a subagent is described, altering which script gets called.

A workshop wall of labelled tool outlines, most empty, a few holding tools, with a clipboard of checklists below

How it improves without labels

This is the part that took me a while to accept, because it sounds like it should not work.

The task-level loop is called Propose–Probe–Compose, and it is described as contrastive. The harness editor proposes two kinds of edits: invariant edits and domain edits. Candidate harnesses get executed on the same task. Then a composer looks at the behavioral differences between the runs and assembles a refined harness from them.

Note what is missing: ground-truth feedback. There is no reward model, no human label, no "this answer was correct" signal. The system is comparing its own runs and asking which behaviors differ, then keeping the harness that produced the behavior it wants.

That works because most agent failures are visible without a label. The agent called a tool with a malformed argument. It looped three times on the same file. It wrote a summary but never opened the document. You do not need to know the right answer to see that the trajectory was broken. Contrastive comparison is enough to surface those, and a harness that stops producing broken trajectories scores better on whatever the benchmark measures.

The second loop is the one that makes it a system rather than a trick. A persistent improvement harness accumulates the adopted harnesses and the evidence-backed lessons from each task, and uses them to guide the next refinement. In other words, it gets better at getting better, and the thing that improves is not the model.

The benchmark result, and how to read it

Three benchmarks: JobBench for professional work, LAB for legal work, WorkBuddy-Bench for office, web and code. Four model–harness configurations. One step of recursion.

The gains — 11.5 points, 4.5 points, 11.8 percentage points — are large for a method that changes nothing but text. Two things make them more believable than the usual agent-benchmark claim.

First, the baselines are real harnesses, not a naked model. They are comparing against OpenCode and Codex, which are competent scaffolds. Beating a competent scaffold by 11 points on an office-task benchmark is not the same as beating a chat completions call.

Second, the paper reports that increasing the task-level recursion budget brings further gains. A method that only works at k=1 is usually a prompt trick that got lucky. A method that scales with budget is doing search, and search tends to be real.

What I would want before believing the absolute numbers: how much of the gain survives a different benchmark in the same domain, and how much of it is the harness finding the benchmark's rubric. That is not a criticism of the authors. It is the standing problem with every agent benchmark in 2026.

The eval-integrity warning is in the README

Under "Web access," the README says something that deserves to be quoted rather than paraphrased: executor network access is unrestricted, Codex runs with its sandbox disabled, and public benchmark rubrics may be accessible online. Before evaluation, configure network restrictions to prevent access to benchmark answers and grading criteria.

That is an admirably direct warning, and it is also an admission about the entire field. If your agent has unrestricted internet and your benchmark has public rubrics, then some fraction of your measured improvement is the agent finding the answer key. The authors flag it and provide the mitigation. Most releases do not.

It matters more here than usual, because harness optimization is specifically the process of finding whatever makes the score go up. Give that process an internet connection and a public rubric and you have built a very efficient rubric-finder.

What this changes for people building agents

Three practical shifts, if the method holds up.

The harness becomes an artifact you version. Right now, an agent's behavior lives in a prompt file, a tool list, and a few skills, and it changes when someone edits the prompt. Harness² produces an adopted harness per task, saved under runs/, with reflection notes. That is a much better unit of review than a diff on a 4,000-token system prompt.

Per-task specialization becomes cheap. The whole premise is that the harness should be tuned to the task in front of it, not shipped as one global configuration. If one recursion step is affordable — and it is, compared to fine-tuning — then "we have a legal harness and an office harness" stops being an architecture decision and becomes a runtime decision.

The model's job description narrows. If 11 points can come from the scaffolding, then a lot of what people call "model capability" on agent benchmarks is actually harness quality, and the leaderboard is measuring the wrong object. That is an uncomfortable conclusion for anyone whose product is a base model, and a liberating one for anyone whose product is a workflow.

The honest limit

Harness² optimizes against a benchmark. It does not know what you want. If your benchmark is a poor proxy for your users — and it always is, a little — then the recursion will confidently optimize the proxy, and you will get an agent that is better at the test and not better at the job.

That is not a flaw in the paper. It is the shape of the whole field right now: we have gotten very good at measuring agents and not much better at specifying what we actually want them to do. The interesting thing about this release is that it makes the second problem impossible to ignore. Once the harness is a variable you can search over, "what should the harness optimize for" stops being a philosophical question and becomes the only question left.

Related articles