Google Open-Sources Harness²: Framework That Improves Agents Without Touching Model Weights

Google Cloud AI Research has open-sourced Harness², a recursive agent harnessing framework that improves the code and files surrounding a frozen model rather than the model itself. A single refinement step improved all four tested model-and-harness setups on all three benchmarks, with the largest gain reaching 11.5 points: GLM-5 under OpenCode rose from 64.2 to 75.7 on WorkBuddy-Bench.

The release is version 0.1.0, available on GitHub under an Apache-2.0 license, and described in a paper on arXiv (2610.14224). The project is a framework, not a model. It trains zero parameters and exposes 8 editable harness components. For developers, the pitch is direct: your agent may get better without a better model.

That claim matters because the industry's default path to better agents has been better weights, at higher training and inference cost. Harness² targets the opposite lever — everything around the model — and it targets the hardest setting: the open world, where tasks arrive unseen and no verifier confirms whether an answer is correct.

What exactly is a harness, and what changes?

A harness is everything around the model: prompts, tools, memory, skills and orchestration. Harnessing is the process of optimizing that system. In Harness², model weights never change. The framework refines the harness during deployment, task by task.

Harness² exposes 8 editable components, each mounted as a file:

1. System prompt
2. Guardrails
3. Memory
4. Tool guidance
5. Subagents
6. Skills
7. Scripts
8. Plugins (middleware)

The components cover context construction, the tool interface, delegation and behavior inside the tool loop. The layout extends the 7-file split from earlier Agentic Harness Engineering work by one component.

The research team's core argument is that most self-improvement methods assume labels or test cases. Harness² is built to work without them. Instead of checking answers against ground truth, it compares behaviors — a design choice aimed at open-world tasks where no such ground truth exists.

How does recursive agent harnessing work?

The framework runs two linked levels of recursion.

Task-level recursion uses a contrastive Propose, Probe, Compose step. First, the agent runs the task once with the base harness. An editor then proposes 2 candidates. The invariant candidate targets general agent failures such as planning or tool use. The domain candidate targets knowledge and procedures for the current domain. Both candidates run on the same task. The composer compares their trajectories against the reference and keeps only edits backed by observed behavior.

Harnessing-level recursion happens after each task. A reflector stores the adopted harness plus an EXPERIENCE.md file of lessons. This library guides future proposals. Each new task still starts from the base harness.

The budget k scales the search. Parallel mode probes k invariant and k domain candidates, then makes k compositions. Sequential mode chains k refinement steps.

The evidence for the library's value is concrete: removing it cut WorkBuddy-Bench performance from 77.5 to 74.4, according to the project's own ablation.

How did it perform on benchmarks?

The research team tested 3 professional benchmarks: WorkBuddy-Bench, JobBench and Harvey's LAB. Executors were Gemini 3.5 Flash and GLM-5, each running under OpenCode and Codex. The default editor was Claude Opus 4.8. Results are means over 3 runs, with a single improvement step at k=1:

Setup (k=1)	WorkBuddy Avg	JobBench	LAB Partial
Gemini 3.5 Flash, OpenCode	72.4 → 77.5	31.5 → 36.0	79.9 → 81.9
Gemini 3.5 Flash, Codex	74.5 → 77.5	33.9 → 35.3	71.6 → 75.6
GLM-5, OpenCode	64.2 → 75.7	20.6 → 24.2	59.6 → 71.4
GLM-5, Codex	64.4 → 75.3	23.6 → 24.8	58.1 → 65.9

The weakest gains were modest: GLM-5 under Codex added only 1.2 points on JobBench, moving from 23.6 to 24.8. But the pattern held across the board. Weaker executors gained more. After one step, GLM-5 beat base Gemini 3.5 Flash on WorkBuddy-Bench — a smaller model matching a larger one on the strength of its harness alone.

Parallel recursion scaled further. At k=5, Gemini under OpenCode reached 80.8 on WorkBuddy-Bench, up from 77.5 at k=1. Efficiency also improved: on WorkBuddy-Bench, 3 of 4 setups used fewer steps per task. Gemini under OpenCode fell from 25.4 to 21.9 steps.

The comparison carries a caveat noted in the source: the other methods' scores were measured in the Harness² paper and were not reported by those methods on these benchmarks themselves.

How does it compare with other harness methods?

The paper measures Harness² against three baselines: Meta-Harness from the Stanford IRIS Lab and co-authors, ReasoningBank from Google Research and co-authors, and Harness Scaling by Wang et al.

Feature	Harness²	Meta-Harness	ReasoningBank	Harness Scaling
Developers	Google Cloud AI Research, Northwestern	Stanford IRIS Lab and co-authors	Google Research and co-authors	Wang et al.
What changes	Full 8-component harness, per task	Harness code, searched offline	Retrieved memory; harness fixed	Harness, revised per instance
Needs training split	No	Yes	No	No
Learns across tasks	Yes (library + lessons)	Deploys 1 best harness	Yes (memory)	No
Code license	Apache-2.0	MIT	Not disclosed	Not disclosed
WorkBuddy Avg, Gemini/OpenCode	77.5 (80.8 at k=5)	76.4	73.4	75.3
JobBench, Gemini/OpenCode	36.0	35.8	30.8	32.9
LAB Partial, Gemini/Codex	75.6	76.5	74.8	67.9

The scores are close at the top. Meta-Harness edges Harness² on LAB Partial, 76.5 to 75.6, but Meta-Harness requires a training split and optimizes offline on separate tasks. Harness² needs no training split, refines per task, and carries lessons forward through its library. ReasoningBank and Harness Scaling trail on every measured benchmark in the table.

How do you install and run it?

The README targets Linux with Python 3.12 and uv. A local demo runs both recursion modes without model credentials:

uv venv --python 3.12 .venv
source .venv/bin/activate
uv pip install -e '.[render]'
harness2-demo --output runs/demo --k 2

Model-backed runs require more. They call models through Vertex AI, which means Node.js 20+, the Google Cloud CLI and a Vertex AI project. Benchmark reproduction adds dependencies: LAB needs Pandoc and Poppler, and WorkBuddy-Bench needs Docker. Executors are OpenCode by default, or Codex with --substrate cx. The GitHub repository does not disclose a GPU requirement. Python 3.13 also appears in the stated runtime requirements.

What are the practical trade-offs?

Two costs come with the gains. First, the method expects extra runs per task: at k=1, a single task consumes one reference run, two probes and one final run. Second, the project's own takeaways advise users to sandbox it themselves — the framework rewrites and executes its own harness components, which is exactly the kind of capability that warrants isolation.

The core takeaways from the release:

• Harness² rewrites an agent's harness at test time; weights stay frozen.
• One step lifted GLM-5 by 11.5 points on WorkBuddy-Bench.
• Propose, Probe, Compose replaces ground-truth labels with behavioral contrasts.
• A lessons library carries improvements to future tasks.
• Expect extra runs per task, and sandbox it yourself.

Why this matters

The result reframes where agent improvement budget should go. If an 11.5-point gain on a professional benchmark is available from rewriting prompts, tools and orchestration files — with zero parameters trained — then harness engineering becomes a measurable competitor to model upgrades, at least for deployments already locked to a fixed model. The finding that weaker executors gained more, and that one step let GLM-5 overtake base Gemini 3.5 Flash on WorkBuddy-Bench, suggests the technique narrows the gap between frontier and mid-tier models at inference time.

The competitive position is also worth watching. Harness² outperformed all three measured baselines on WorkBuddy-Bench and JobBench, and lost only to Meta-Harness on LAB Partial — while remaining the only top-scoring method that needs no training split and refines per task rather than deploying one static harness. With an Apache-2.0 license and a credentials-free demo, the barrier to testing that claim is a four-command install.