Harness²: Google Research lets agents rewrite the system that surrounds them

Harness²: Google Research lets agents rewrite the system that surrounds them

🔎 A framework that never touches the model — and yet it works

The race for AI agents has long boiled down to a single question: which model to put under the hood? Google Cloud AI Research has just proposed a different answer, a more unsettling one. What if the real performance lever wasn't the model, but everything that surrounds it — the prompts, the tools, the memory, the scripts?

That's the thesis of Harness², an open-source framework released in early October 2026 under the Apache 2.0 license, accompanied by a paper on arXiv (2610.14224). The principle can be summed up in one sentence: instead of improving the model's weights, you let the agent rewrite its own harness — the software layer that makes it run. The repo google-research/harness2 already shows 16,700 stars and made it to GitHub trending as soon as it was published.

The announced numbers deserve a closer look: up to +11.5 points on WorkBuddy-Bench, +4.5 on JobBench and +11.8 points on LAB, with models as different as GLM-5 and Gemini 3.5 Flash. No fine-tuning. No retraining. With frozen weights.

The essentials

• Harness² is a "recursive agent harnessing" framework: the agent iteratively optimizes the eight components surrounding it (system prompt, guardrails, memory, tool guidance, subagents, skills, scripts, plugins) rather than its own weights.
• Two recursion mechanisms: a Propose-Probe-Compose loop that works without any ground truth, then a persistent experience loop that retains the lessons from every task executed.
• Measured gains: +11.5 points on WorkBuddy-Bench, +4.5 on JobBench, +11.8 points on LAB with GLM-5 and Gemini 3.5 Flash; parallel recursion at k=5 adds +3.9 points on WorkBuddy-Bench and +6.7 on LAB Partial.
• Open and pragmatic: Apache 2.0, OpenCode and Codex runners, default harness edited by Claude Opus 4.8.
• Market signal: the harness layer is becoming infrastructure in its own right — as analyzed in the harness layer becomes infrastructure: two of the three trending GitHub repos.

Recommended tools

The harness, that invisible layer everyone underestimates

Direct answer: the harness is the set of software components that turn a raw LLM into a functional agent — and Harness² demonstrates that optimizing this layer pays off as much as switching models.

Concretely, an agent is never "just a model". Between the LLM and the outside world, there's a system prompt, security guardrails, memory management, tool usage instructions, delegated subagents, reusable skills, scripts, and plugins. Harness² structures these elements into eight editable components, all of which can be modified by the agent itself.

The idea isn't entirely new — prompt engineering and meta-prompts have been around for years. What's changing is the recursion methodology. As Marktechpost summarizes: instead of improving the model's weights, the agent rewrites its own harness. It's an inversion of the dominant paradigm, where optimization effort is almost exclusively focused on training.

For context: this publication is part of a broader trend, in which several repos dedicated to the harness layer broke through on GitHub simultaneously — a phenomenon we detailed in our analysis of the harness as the new infrastructure for AI agents.

How the Propose-Probe-Compose recursion works

Direct answer: the agent proposes modifications to its harness, tests them under real conditions, then composes the best configuration — without ever having access to ground truth.

The paper describes two levels of recursion, both with frozen weights:

Level 1: Propose-Probe-Compose

The cycle unfolds in three steps:

1. Propose: the agent generates variants of its harness — a reworked system prompt, a new memory strategy, refined tool guidance.
2. Probe: each variant is run on real tasks, and the results are observed without ground-truth feedback. This is the most interesting part: no need for annotated datasets, which makes the method applicable to open-ended tasks, where nobody has a pre-labeled "correct answer".
3. Compose: the agent assembles the best-performing components into a final configuration.

The default harness is itself edited by Claude Opus 4.8 under OpenCode, which says a lot about the maturity of the approach: this isn't a lab prototype, it's a pipeline that runs on production runners.

Level 2: the persistent experience loop

The second level goes further. Instead of starting from scratch on every task, the agent maintains an experience library: every task executed leaves a trace — what worked, what failed, which harness variants produced which results.

The most striking effect documented in the paper: an experience library transferred from JobBench improves results on WorkBuddy without any additional probing. In other words, lessons learned in one domain transfer to another domain. This is exactly the kind of generalization we expected from fine-tuning — achieved here with simple persistent storage of lessons.

The numbers: what +11.5 points at frozen weights is worth

Direct answer: the gains are substantial and measured across three distinct benchmarks, with two very different model families — which suggests the method is not overfitted to any particular LLM.

Three observations stand out.

First: the gains vary considerably depending on the benchmark (+4.5 vs +11.5 on WorkBuddy). This suggests that harnessing benefits tasks where prompt structure and tool management are decisive — typically "work buddy"-style workflows — more than tasks where raw model capability dominates.

Second: parallel recursion at k=5 (five variants explored simultaneously) delivers more modest gains than full recursion. The compute cost of the full version is therefore probably significant — a trade-off teams will have to weigh.

Third: the fact that the method works on both GLM-5 (a self-hostable model, which we rank at 82 on our agentic index) and Gemini 3.5 Flash (a lightweight proprietary model) is perhaps its strongest argument. If you're hesitating over the best LLM for your AI agents, Harness² changes the question: the model becomes one variable among eight, not THE variable.

Why this is good news for open source and local agents

Direct answer: Harness² makes agent optimization accessible without training GPUs or a fine-tuning budget — a democratizing lever for the local ecosystem.

Fine-tuning remains the preserve of those who have clusters, data, and ML teams. Recursive harnessing, by contrast, requires only an LLM — any LLM — and an executor. For developers running agents locally with Ollama, this opens a door: the method is documented to work with self-hosted models like GLM-5.

This dovetails naturally with the approaches we cover in open source AI agents running locally with Ollama: Harness² brings a systematic optimization methodology where most local setups still rely on artisanal prompt engineering, hand-tuned, with no measurement loop.

Another interesting architectural point: Harness² relies on executors (OpenCode, Codex) that connect to the model via standardized interfaces. If you want to hook the harness up to a model other than the default ones, gateways like Magpie, the local gateway that connects 60 coding agents to any model enable precisely this decoupling between harness, executor, and LLM. It's the same philosophy: every layer must remain replaceable.

What It Doesn't Solve: The Paper's Limitations

Direct answer: Harness² optimizes the software layer, not the model's cognitive capabilities — and the gains depend on the benchmark chosen.

Let's be precise about what these numbers don't tell us.

A gain of +11.5 points on WorkBuddy-Bench is not a gain of +11.5 points across all tasks. The benchmarks cited (WorkBuddy, JobBench, LAB) are structured agentic work environments. On pure reasoning tasks, where the model is already the limiting factor, rewriting the system prompt won't work miracles. A model at 82 won't become a model at 95 through harnessing magic.

Recursion costs compute. Proposing, testing, and composing variants means running the agent multiple times per optimization cycle. At k=5, you multiply your API calls or local inference load by five — before you've even produced the final configuration. For personal use, that's manageable. For a fleet of agents in production, you need to budget for it.

The persistent experience loop raises governance questions. An agent that accumulates lessons from its own executions, and feeds them back into its future behavior, is an agent whose behavior drifts over time. This is exactly the kind of problem raised by the Google- and SAP-led effort to govern enterprise agents on agentic AI governance: a self-modifying harness must be auditable, versioned, and reversible. Harness² publishes its code under Apache 2.0, which helps — but auditability isn't automatic, it has to be built.

OpenCode, Codex and the executor ecosystem

Direct answer: Harness² doesn't reinvent agentic execution — it plugs into two existing executors, OpenCode and Codex, which accelerates adoption.

The choice of these two executors is strategic:

• OpenCode is the go-to executor in the open source scene, with native multi-model support. It's the one hosting the default harness edited by Claude Opus 4.8 in the paper's experiments.
• Codex (OpenAI) covers the proprietary ecosystem, and makes it possible to test the method on GPT-5.x models — including GPT-5.5, currently at the top of our agentic LLM ranking.

This modular architecture — harness on one side, executor on the other, model underneath — is the project's true architectural contribution. It makes it possible to answer a question that few frameworks honestly ask themselves: how much of the performance comes from the model, and how much comes from everything else? Harness²'s results suggest that "everything else" weighs heavily.

For developers who want to experiment without committing an API budget, the free AI APIs from Groq, Google, and OpenRouter offer a zero-cost entry point for running probing cycles on lightweight models — ideal for validating the method before pushing it to production.

❌ Common Mistakes

Mistake 1: confusing harnessing with fine-tuning

Recursive harnessing modifies no weights at all. If your task requires capabilities the model doesn't have (advanced mathematical reasoning, niche multilingualism), rewriting the harness won't create them. The solution: first choose a model suited to the task, then optimize the harness. Not the other way around.

Mistake 2: ignoring the cost of recursion

The gains of +11.5 points are achieved with full recursion — which is therefore costly. Many teams copy the numbers from the paper without anticipating that each Propose-Probe-Compose cycle multiplies executions. The solution: start with parallel recursion at k=5 (+3.9 to +6.7 points depending on the benchmark), measure the gain/cost ratio, then scale up if the ROI justifies it.

Mistake 3: deploying a self-modified harness without auditing

An agent that rewrites its own system prompt and its own memory can drift. In an enterprise setting, that's a compliance risk, not a technical detail. The solution: version every harness iteration, log the changes, and keep a human in the loop to validate structural changes — in the spirit of emerging governance frameworks.

Mistake 4: extrapolating the benchmarks

WorkBuddy-Bench, JobBench, and LAB are specific environments. A gain of +11.8 points on LAB guarantees nothing for your use case. The solution: reproduce the method on a small sample of your own tasks before any deployment.

❓ Frequently Asked Questions

Is Harness² really free and usable commercially?

Yes. The code is published under the Apache 2.0 license on GitHub, which permits commercial use, modification, and redistribution. You only pay for model inference and the compute costs of recursion. Documentation and detailed results are available on the project page.

Do you need a powerful model for the method to work?

The paper documents gains with GLM-5 and Gemini 3.5 Flash — two very different profiles in terms of size and cost. The whole point of harnessing is precisely to partially compensate for a model's weaknesses with a better orchestration layer. A well-harnessed mid-tier model can beat a poorly orchestrated strong model on structured agentic tasks.

How is this different from classic prompt engineering?

Prompt engineering is manual, static, and one-off: a human writes a prompt, tests it, adjusts it. Recursive harnessing is automated, iterative, and systematic: the agent itself proposes, tests, and composes variants, and stores the lessons in a persistent library. It's the difference between tinkering and industrializing.

Does the experience library transfer across domains?

Yes, and this is one of the most promising findings of the paper: a library built on JobBench improves performance on WorkBuddy without any additional probing. This suggests that some lessons from the harness (error handling, tool call structure) are generic and transfer beyond the original domain.

Can you use Harness² with local models?

Yes, provided you go through a compatible executor (notably OpenCode) and a self-hostable model like GLM-5. Since the method uses frozen weights, it requires no training GPUs — only inference, which makes it viable on local setups.

✅ Conclusion

Harness² doesn't offer a better model — it offers a way to stop expecting everything from the model. With gains of +11.5 points at frozen weights, an Apache 2.0 license, and a modular harness/executor/LLM architecture, Google Cloud AI Research has just legitimized a conviction that is gaining ground in the ecosystem: the harness layer has become first-class infrastructure. The code is on GitHub, the paper on arXiv — and if you want to pick the right model to place under your harness, our guide to the best LLMs for AI agents is the logical starting point.