What Is Google Harness²?
Harness² is an open-source framework designed to help AI agents improve how they complete tasks without changing the underlying model's weights.
The project is described in the research paper Harness²: Recursive Agent Harnessing for an Open World, published on arXiv in October 2026. Its accompanying code is available in the official GitHub repository. The repository uses the Apache 2.0 license for Harness² itself, although third-party components and benchmark datasets may have separate terms.
To understand why this matters, it helps to separate an AI model from the system that allows it to perform real work.
An AI model generates responses and reasons about instructions. An AI agent also needs tools, memory, instructions, and a process for completing tasks. This surrounding system is often called the harness.
For example, an AI agent that prepares a business report may need to open files, extract data, calculate totals, create a spreadsheet, and check its final output. Even a powerful model can make mistakes if its instructions are unclear or its tools are poorly organized.
Harness² attempts to improve this surrounding system by testing changes, comparing execution behavior, and keeping useful lessons for future tasks.
The important distinction is that Harness² improves the agent's working environment rather than retraining the underlying model.
That approach could be useful because improving an agent does not always require building a larger model. Sometimes, better tools, clearer instructions, and more reliable workflows can make a meaningful difference.
Why Traditional AI Self-Improvement Often Fails
Recursive self-improvement, or RSI, is the idea that an AI system can improve parts of its own operation and use those improvements to perform better in the future.
The idea sounds simple: let an AI agent inspect its mistakes, change its instructions, test new approaches, and keep the changes that work.
However, real-world tasks make this difficult.
1. Many tasks do not have simple correct answers
In a math test, a system can compare its answer with the correct result. In software testing, automated tests can show whether a function works.
But what happens when an AI writes a business plan, reviews a contract, or prepares a research report?
There may be no single correct answer that can easily be checked. A report can be well written but miss an important detail. A legal analysis can sound convincing but overlook a key issue.
Without reliable feedback, an AI system may struggle to decide whether changing its instructions actually improved the result.
2. Improvements may only work for one task
An agent might discover a useful change while working on a spreadsheet. However, that change could make it less effective at writing code or researching a topic.
This is a form of overfitting: the system becomes better at one specific situation without becoming more capable in general.
Repeated changes can also create new problems. A prompt that fixes one mistake might introduce another, while extra rules and instructions can make the system more complicated.
Harness² is designed to address these challenges through two connected improvement processes: task-level recursion and harness-level recursion.
How Harness² Works: Two Layers of Improvement
Layer 1: Task-level recursion
Layer 2: Harness-level recursion
The two layers serve different purposes. The first tries to improve the current task. The second tries to improve the process used to make future improvements.
Layer One: Propose, Probe, and Compose
The first layer uses a process called Propose–Probe–Compose.
Propose: The system examines an initial task attempt and proposes changes to the agent's setup. These may target general problems, such as poor planning or repeated tool calls, or issues specific to the task.
Probe: The system runs the proposed changes on the same task and compares the resulting execution paths with the original attempt.
Compose: The system uses the available behavioral evidence to select and combine promising changes into a revised setup.
The key idea is that the system does not always need a perfect reference answer to evaluate a change. It can examine what happened during execution, whether a previously blocked step was resolved, and whether the new approach introduced other problems.
This does not mean the system can reliably identify every mistake without an external judge. Behavioral comparisons provide evidence, but they cannot guarantee that the final answer is correct.
Harness² also supports parallel and sequential recursion. Parallel recursion explores multiple candidate changes at the same time, while sequential recursion carries lessons from one improvement step into the next.
Layer Two: Building a Library of Experience
The second layer focuses on learning from completed tasks.
Instead of discarding the debugging process after delivering an answer, Harness² records information about the original execution, candidate changes, comparison evidence, and selected improvements.
A reflection component can turn these records into reusable notes, including an EXPERIENCE.md file. The system stores the resulting lessons in an improvement library that can guide future changes.
Imagine an agent that repeatedly struggles with large spreadsheets. It might discover that checking column names before calculating totals reduces errors.
That lesson could help the system improve its approach to similar spreadsheet tasks later.
However, the same rule might not be useful for a coding or legal research task. The goal is not to apply every old improvement everywhere. It is to reuse relevant experience when the situation calls for it.
This makes Harness² more than a system for adjusting prompts. It is an attempt to build a repeatable process for improving the way AI agents are configured.
Harness² Benchmark Results: How Much Did Performance Improve?
The research evaluates Harness² using three professional task benchmarks: WorkBuddy-Bench, JobBench, and LAB, a legal agent benchmark.
The reported experiments use GLM-5 and Gemini 3.5 Flash with OpenCode and Codex execution environments. The paper reports improvements across the tested configurations.
Here are the WorkBuddy-Bench results reported for a single improvement step.
Model and setup | Original score | Improved score | Gain |
|---|---|---|---|
GLM-5 with OpenCode | 64.2 | 75.7 | +11.5 |
GLM-5 with Codex | 64.4 | 75.3 | +10.9 |
Gemini 3.5 Flash with OpenCode | 72.4 | 77.5 | +5.1 |
Gemini 3.5 Flash with Codex | 74.5 | 77.5 | +3.0 |
Scores and gains are from the reported benchmark results. They are benchmark-specific measurements, not percentages of overall AI intelligence.
The largest improvement in this table is GLM-5 with OpenCode, which increases from 64.2 to 75.7.
That is an 11.5-point gain. In these particular results, the improved GLM-5 score also exceeds the original Gemini 3.5 Flash score under both listed execution setups.
This is an important result because it suggests that a model's performance depends not only on its underlying capabilities but also on the system surrounding it.
The research also reports gains on the other benchmarks:
👉JobBench: Improvements of up to 4.5 points in the reported single-step experiments.
👉LAB: An increase of up to 11.8 percentage points in the partial pass rate for GLM-5.
👉Larger search budgets: Additional improvements when the system explores more candidate changes.
- arXiv+1
These results are promising, but they should be interpreted carefully. Benchmark scores depend on the tasks, evaluation methods, models, and execution environments used in the experiments. They do not prove that every AI model will immediately become better at every real-world job.
Can More Testing Make Harness² Even Better?
The research explores increasing the number of candidate improvement paths.
In the parallel approach, the parameter \(k\) controls the number of candidate paths explored. At \(k=5\), the system can examine more potential improvements than it does in a single-step run.
The supplied results report additional gains of up to 3.9 points on WorkBuddy-Bench, 4.2 points on JobBench, and 6.7 percentage points on the LAB pass rate.
Exploring more candidates can help the system find better changes, but it also requires more execution and evaluation work. That can increase computing costs and the time needed to complete a task.
The trade-off is important for businesses. A small improvement might be worth the extra cost for a high-value legal or financial task, while a simple everyday task may not need multiple rounds of optimization.
Harness² therefore offers a way to explore the balance between improved performance and additional resources.
Why Cross-Domain Learning Matters
One of the most interesting ideas in Harness² is the ability to reuse lessons across different types of work.
According to the supplied results, the researchers transferred an experience library developed using JobBench to WorkBuddy-Bench. They reported additional gains of 0.6 points in coding, 0.5 points in web tasks, and 2.9 points in office tasks without increasing the probing budget.
This matters because businesses rarely use AI for only one kind of task.
A single agent platform might support research, coding, document editing, data analysis, and customer support. Improvements that apply across several areas could save developers time and reduce repeated configuration work.
Still, transferring experience is not the same as guaranteeing universal learning. Some lessons may be useful across domains, while others depend heavily on the task or software environment.
The reported results offer early evidence that carefully recorded experience can help an agent improve beyond the specific tasks where that experience was first collected.
How Developers Can Access Harness²
Harness² is available through the official Google Research GitHub repository, and the project documents support for OpenCode and Codex. Its repository identifies the main framework license as Apache 2.0.
Developers interested in trying it should review the installation instructions, benchmark requirements, and configuration options before starting.
The project requires a suitable software environment, and model-backed experiments may require cloud credentials and incur API costs. Some benchmarks also have their own installation requirements and licensing terms.
One important distinction: the repository is hosted under the Google Research organization, but it explicitly states that Harness² is not an officially supported Google product. Developers should not assume that it comes with standard Google product support.
Final Thoughts: A New Way to Improve AI Agents
Harness² highlights an important direction in AI development: improving the systems around models rather than relying only on larger models or additional training.
Its two-layer approach attempts to solve two difficult problems. First, it uses execution evidence to test improvements when a perfect answer is unavailable. Second, it stores useful lessons so that future tasks can benefit from previous experience.
The reported benchmark gains are encouraging, especially the 11.5-point improvement for GLM-5 on WorkBuddy-Bench. However, further evaluation is needed to understand how consistently these gains transfer to different models, tasks, and real business environments.
For developers, the project offers an open-source way to explore runtime optimization and recursive agent improvement. For businesses, it raises an important possibility: better AI performance may sometimes come from better tools, instructions, and workflows rather than a more expensive base model.
The big takeaway: AI agents may become more useful not only by becoming smarter at their core, but also by learning how to organize and improve the systems they use to get work done.
Keywords: AI self-improvement, recursive self-improvement, AI agents, AI agent framework, runtime optimization, Harness² framework, Google AI research, GLM-5 benchmark, AI agent performance
************************************************************************************************************************
0 Comments