Google, Anthropic and OpenAI in one experiment: Gemini does the work, Codex is the structure and Claude redesigns it all

One Google experiment brings together Gemini, OpenAI’s Codex and Anthropic’s Claude, each with a different role. And the piece that changed least was the model.

Harness², published by Google Cloud AI Research and Northwestern University, shows that an AI agent can perform much better without changing a single model parameter: improving how it works is enough, which is what is now called harness engineering. It is the same idea we apply when we build AI agents for companies.

For two years we have been waiting for the next model that changes everything. This work suggests a good part of the answer lies elsewhere: not in the agent’s brain, but in the way it works.

What Google’s Harness² is

On 9 October 2026, Google Cloud AI Research and Northwestern University released Harness² (also written Harness2): an arXiv paper and an open-source framework under the Apache 2.0 license.

The question it asks is ambitious: can an AI agent improve the way it works and also learn to improve it better each time? All without touching a single model parameter.

To see why it matters, we first need a concept that is becoming central in AI: the harness.

What is a harness in an AI agent?

The paper sums it up in a formula: Agent = Model + Harness.

• The model is the LLM: Gemini, Claude, GPT, GLM. It takes text in and produces text. On its own it executes nothing, remembers nothing between sessions and does not act on the world.
• The harness is everything around the model that lets it act: instructions, tools, memory, skills and orchestration.
• The agent is the result of combining both (for background, read what an AI agent is).

A common point of confusion: tools are not something the agent "already has" apart from the harness. Tools are part of the harness. A model with tools wired in is already a model with a harness, even a simple one.

The word itself explains it. A horse is strong, but without a harness it cannot pull a cart in a useful way. The harness does not make the horse stronger; it channels its strength into a specific job.

Claude Code, Codex, OpenCode, OpenClaw and Hermes Agent are, at heart, harnesses: structures that turn a model into an agent that can do real work.

Why does it matter so much? Because the same model can perform very differently depending on the harness around it. That is why, in 2026, people increasingly talk about harness engineering: competition is no longer only about models, but about how they are put to work.

Google, Anthropic and OpenAI: three roles

Here is the striking part. In the main Harness² experiments, each piece comes from a different company:

Two telling details:

• Codex worked with non-OpenAI models. Harness and model are interchangeable parts: you can take one vendor’s structure and give it another vendor’s brain.
• Google chose Claude as the default editor while Gemini did the work. This is not a rumor: it is in the paper’s implementation section.

An important clarification: Claude was not used to build Harness². It is used inside Harness², at run time, every time the system improves an agent. And it is not required: as we will see, it works with other models too.

How Harness² works: the recursive harness

Put simply: the system improves the agent’s harness while it works and also learns to improve it better each time. The model is not touched. It works on two levels.

Within each task: propose, test, combine

1. Propose. The agent does the task with its starting harness. Based on how it worked, the editor proposes two improved versions: one with general improvements (better planning, better tool use) and one specific to the domain (procedures and rules for that kind of work).
2. Test. It runs both versions on the same task and compares how the agent behaved in each.
3. Combine. It keeps only the changes that proved helpful and builds the final harness.

The interesting part is that it does this without knowing the correct answer. It needs no answer key: it decides by comparing behaviors.

Across tasks: learning to improve

After each task, the system reflects on the whole process and stores the harnesses that worked and the lessons learned in a library. The next task starts again from the base harness, but the "improver" now knows more. That is the recursion: it does not only improve the agent, it improves the way it improves it.

What it can change

Not just the prompt. Harness² can edit eight components: system instructions, guardrails, memory, tool-use guidance, subagents, skills, scripts and plugins. In other words, it can write its own scripts (in practice, create tools), create new skills or delegate to subagents.

A real example from the paper. On a JobBench task, the base agent scored 43.1: it did not reconcile data across files and never checked what it delivered. Harness² added a verification rule with a script to reopen and check its files, a reconciliation skill and more precise tool guidance. Result: 77.8. Same model, different way of working.

Results: the finding that should make us uncomfortable

Google tested Harness² on three professional benchmarks: WorkBuddy-Bench (office, web and code), JobBench (professional work) and LAB (legal work). With a single improvement step, every agent improved on every benchmark.

And when it is allowed to explore more alternatives per task, the gains keep growing.

But the most powerful finding is a different one: a weaker model with an improved harness beat a stronger model with its original harness. On WorkBuddy-Bench, the improved GLM-5 reached 75.7, above the 72.4 of Gemini 3.5 Flash with its starting harness. The authors themselves highlight it in the paper.

And another conclusion that prevents a misreading: Claude is not essential. The researchers tried using the same model as executor and editor, so that each model redesigned itself. All five models tested, from GLM-5 to Claude Opus 5, improved on every benchmark. The gain does not depend on having a more powerful editor.

What Harness² is not (yet)

Before the enthusiasm runs ahead, four honest caveats:

• It is research, not a product. The repository itself says it is not an officially supported Google product. It is not an assistant you install like OpenClaw or Hermes: it is a command-line tool for developers and researchers that currently works with OpenCode and Codex on three benchmarks.
• It improves tasks; it does not leave a permanently better agent. Each new task starts from the base harness. What accumulates is the "improver’s" knowledge, not an ever-better agent ready for production.
• It is not free. To improve, it explores: it runs the agent several times per task, plus the editor’s calls. The paper shows a good quality/compute balance against other improvement methods, but does not compare it with simply using a more expensive model. The right question is not "is it cheaper?" but "what does each result I actually accept cost me?".
• There is no human in the loop. The whole cycle is automatic: propose, test, combine and learn. By default, the agent also has unrestricted network access and Codex runs without a sandbox. Bringing something like this into a company means putting people back in and adding external limits: if an agent can rewrite its own rules, those rules cannot be the only thing containing it (see AI agent security).

The underlying lesson

First came ready-to-use harnesses such as OpenClaw. Then came harnesses that learn with use, such as Hermes Agent, which accumulates skills and memory. Now, with Harness², research points to harnesses that redesign themselves systematically and check whether the change worked.

Claude was the default editor, but the lesson is not about Claude. Nor about Google or OpenAI. It is that the way an agent works can be optimized systematically, just as we used to optimize models.

And that leaves an open question: can a cheap model with an optimized harness compete with an expensive model with a standard harness? Harness² does not fully answer it yet, but it opens the door to measuring it.

What it means for AI agent development in your company

For a company that wants an AI agent, this translates into concrete decisions:

1. Before switching models, review the harness. Ambiguous instructions, poorly described tools or a missing verification step explain many failures blamed on the model.
2. Measure with real cases. Harness² decides by comparing behavior on the same task. In a project, that is a set of test cases from your process against which every change is compared.
3. Add verification. The jump from 43.1 to 77.8 came largely from making the agent check what it delivered.
4. Keep people and limits outside the agent. Least-privilege access, human approval for critical actions and action logs.
5. Measure cost per accepted result, not cost per model call.

How we apply harness engineering

We are an AI agent development team in Lima, Peru, working with US and European companies as a nearshore outsourcing partner, on UTC−5 during US business hours. In every project we treat the harness as an engineering component in its own right: we define instructions, tools, verification rules and human approval points, and we test every change against real cases from the client’s process before it reaches production. When an agent fails, we first review how it works and only then assess whether a different model makes sense. We follow research such as Harness² to bring what works into real projects.

If you want an agent for your company, read how an AI agent is developed, see our nearshore AI agent development service or the guide to outsourcing AI agent development to Latin America. You can also chat with our agent and try it.

So we leave the question with you: if your agent fails, do you change the model or change the way it works?

Sources

• Harness²: Recursive Agent Harnessing for an Open World (arXiv paper)
• Official GitHub repository
• Project page
• Wavect: Google Harness², setup, benchmarks and real cost (in Spanish)