Google Harness2 is a new open-source framework from Google Research that lets an AI agent improve its own setup, meaning its prompts, tools, memory and skills, without touching the model at all. It's written Harness² and you say it "Harness squared". The model stays exactly the same. What gets better is everything wrapped around it.
📺 Watch: Google Harness²: NEW Self-Improving AI Agent!
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
I covered it in my video "Google Harness²: NEW Self-Improving AI Agent!" on 20 October 2026. This page is the written version: what it is, how it works, what the numbers say, and how you can use the same idea in your own agents today, even if you never touch the code.
What Google Harness2 is
Start with the word "harness". Per Google's paper, a harness is the system around a model that lets it act as an agent. That means the prompts, the tools, the memory, the skills and the orchestration. Harnessing means optimising that system.
Harness² is a plug-and-play framework for recursive agent harnessing in what the paper calls an "open world". That's a world where agents run into tasks nobody planned for. Instead of a human rewriting the setup every time the agent struggles, the agent tests changes to its own harness and keeps what works. Model weights stay fixed.
The paper is "Harness²: Recursive Agent Harnessing for an Open World" (arXiv 2610.14224) by Xu, Chen, CuiZhu, Dalvi Mishra, Ming, Yu, Han, Lee and Pfister. The code lives at google-research/harness2, and there's a project page at harness2.github.io.
Model vs harness: the chef and the kitchen
Here's how I explain it. The model is the chef. The harness is the kitchen: the recipes on the wall, the tools, the notes on the fridge, the helpers.
A great chef in a messy kitchen still serves bad food. Wrong recipe, missing knife, nobody told them the customer is allergic to nuts. You don't fix that by hiring a new chef. You fix the kitchen.
That's exactly what I see in my own Agentic Operating System. I run Claude, Hermes, OpenClaw and OpenCode all sharing one memory in Obsidian. When an agent does a job badly, the fix is almost never a new model. It's a rule in a skill file, a missing memory note, or vague instructions. Right now I usually fix that by hand. Harness² hands that job to the agent.
If you want that same setup without building it yourself, the AI Profit Boardroom gives you the Agent OS with shared memory and skill files, a 30-day roadmap and 4 coaching calls a week, for $69/mo.
The results
Per the paper, Google tested Harness² across three professional benchmarks and four model–harness configurations. A single Harness² step improved GLM-5 and Gemini 3.5 Flash over their base harnesses.
| Benchmark | What it tests | Gain |
|---|---|---|
| WorkBuddy-Bench | Office, web and code tasks | Up to +11.5 points |
| JobBench | Professional work | Up to +4.5 points |
| LAB | Legal work | Up to +11.8 percentage points on partial pass rate |
That's one step. Per the paper, a bigger task-level recursion budget brings further gains. Same model, better kitchen, better food.
📺 Watch: Claude AI SEO System Ranks Me #1 on Google
How it works: Propose, Probe, Compose
The first level of recursion happens on each task. Google calls it a contrastive Propose–Probe–Compose step. The clever part is it works without ground-truth feedback. Nobody hands the agent the right answer.
Propose
A harness editor proposes edits to the current harness. Some are general "invariant" edits that should help on any task. Others are domain-specific, aimed at the kind of work in front of it.
Probe
Candidate probes run those edited harnesses on the same task. So you get several versions of the agent attacking one job, each with a slightly different setup. The differences in how they behave are the evidence.
Compose
A harness composer looks at those behavioural contrasts and combines what worked into one improved harness. Think of it as cooking the same dish in four kitchens, then building one kitchen from the best bits of each.
The 8 components Harness² can edit
Per the README, there are eight editable components. They group by role: system prompt, guardrails, memory and skills construct context; tool guidance and scripts define the tool interface; subagents orchestrate delegated work; plugins control middleware, which is behaviour inside the tool loop.
| Component | What it controls |
|---|---|
| System prompt | The core instructions that shape the agent's context |
| Guardrails | Rules and limits on what the agent should and shouldn't do |
| Memory | What the agent knows and carries between steps |
| Skills | Reusable know-how for specific jobs |
| Tool guidance | How and when the agent uses its tools |
| Scripts | Ready-made code the agent can call through its tool interface |
| Subagents | Delegated work handed to helper agents |
| Plugins | Middleware that changes behaviour inside the tool loop |
Look at that list. Most of it is plain English. That's the bit non-coders should pay attention to.
📺 Watch: NEW Google Pomelli Update Is INSANE!
The hidden second loop: harnessing-level recursion
This is the part most people skip, and it's the bit I like most. The second level of recursion sits above individual tasks.
An experience reflector updates a persistent "improvement harness". It stores the harnesses that got adopted and evidence-supported lessons. Then it uses all that to guide the next task. So the agent doesn't just fix its kitchen for tonight's dinner. It learns how to fix kitchens.
The words "evidence-supported" matter a lot. A memory full of guesses makes an agent worse, not better. I've seen it in my own setup: one wrong note in memory and the agent confidently repeats the mistake forever. Harness² only keeps lessons it has evidence for. If you're building memory for your own agents, copy that rule. I go deeper on this in the best Hermes agent memory setups.
Parallel vs sequential recursion
Per the README, you can scale Harness² two ways, and the --k flag sets the budget.
- Parallel recursion probes k general and k domain candidates, then composes k from shared evidence. It "explores wider".
- Sequential recursion carries the refined harness through k steps, improving it each time. It "refines deeper".
Wider is like testing many recipes at once. Deeper is like perfecting one recipe over several nights. Both cost more runs, so pick the budget with your wallet in mind.
How to run it
Here are the basics from the README. This is a technical setup, not a no-code tool.
- Base requirements: Linux, Python 3.12 and uv.
- Free local demo: harness2-demo runs with no model credentials, so you can see the loop before you spend anything.
- Model-backed runs: need Node.js 20+, the Google Cloud CLI and Vertex AI model settings.
- Benchmarks: JobBench, LAB and WorkBuddy-Bench are supported. LAB needs Pandoc and Poppler. WorkBuddy-Bench needs Docker.
- Executors: OpenCode is the default, and Codex is also supported. I run OpenCode in my own Agent OS with a MiniMax model, so this one caught my eye straight away. If you're choosing between agents, see Hermes Agent vs OpenCode.
- Outputs: results save under runs/, including summaries, deliverables, adopted harnesses and reflection notes. Repeat the command to resume.
On cost, the README is blunt: "Model-backed runs incur API costs; start with a small task selection." Each probe is a full run, so costs add up quickly.
On safety, the README warns that executor network access is unrestricted and Codex runs with its sandbox disabled. Configure network restrictions before you run any evaluation. Don't skip that step.
Stuck on where agents like this fit in your business? Book a free AI strategy session and we'll map it out together.
Limits
- It costs more. Every probe is a full agent run, so a step with several candidates multiplies your API bill.
- It's early research code. Version 0.1.0, and per the README, "This is not an officially supported Google product."
- It's technical. Linux, Python, Docker, Vertex AI. If you've never opened a terminal, this isn't your starting point.
- Executor choice is narrow. OpenCode and Codex only, for now.
Still, people clearly want it. The repo was created on 6 October 2026 and had about 15,400 GitHub stars and 1,400 forks at the time of writing. It's under the Apache-2.0 licence.
One commenter on my video said it was "hermes redone basically". Not quite. Hermes already learns skills from experience. Harness² is a research framework for automatically optimising the whole harness: prompts, guardrails, memory, tools, subagents, scripts and plugins together, tested against each other.
How to use the lesson in your own agents today
The big takeaway for non-coders: the setup around the model matters. Instructions, rules, memory and skills are plain English you can improve today in Claude Code, Hermes or OpenClaw. You can run the Harness² idea by hand.
- Stop blaming the model first. When the agent fails, look at the kitchen before you swap the chef.
- Check the system prompt. Is it vague? Make the goal and the finished result specific.
- Add a guardrail. If it keeps making the same mistake, write a rule that says "never do X".
- Fix the memory. Delete guesses. Keep only lessons you've seen proven.
- Write a skill file. Turn any job you repeat into a step-by-step skill. My list of the best Hermes agent skills is a good start.
- Test two versions. Run the same task with your old setup and your new one. Keep what wins. That's Propose, Probe, Compose, done by you.
- Log the lesson. Write down what worked and why, so the next task starts smarter.
My Agent OS guide shows how I wire shared memory and skill files across agents. And if you want to see how I compare agents on real jobs, check Goldie Bench.
Want the done-for-you version? Inside the AI Profit Boardroom you get the Agent OS with shared memory and skill files, the 30-day roadmap and 4 coaching calls a week, all for $69/mo. Prefer to talk it through first? Grab a free AI strategy session.
FAQ
What is Google Harness2?
Google Harness2 (Harness², "Harness squared") is an open-source framework from Google Research that lets AI agents improve their own harness, meaning prompts, guardrails, memory, skills, tools, scripts, subagents and plugins, while the model weights stay fixed. It uses a Propose–Probe–Compose loop on each task plus a persistent improvement harness that carries lessons forward.
Is Harness2 free?
The code is free under the Apache-2.0 licence, and the local harness2-demo runs with no model credentials. Model-backed runs are not free: per the README, they incur API costs, so start with a small task selection.
Does Harness2 work with Hermes or Claude Code?
Not directly. The supported executors are OpenCode (the default) and Codex. The ideas apply to any harness, though. You can improve your prompts, rules, memory and skills in Hermes or Claude Code by hand today using the same test-and-keep-what-works approach.
Is Harness2 an official Google product?
No. It comes from Google Research, but the README states, "This is not an officially supported Google product." It's version 0.1.0 research code, so treat it as an experiment, not a finished tool.
If you want help turning ideas like Google Harness2 into agents that do real work for your business, book a free AI strategy session.
