AI agents can look impressive in a demo and still struggle when the task changes. A model might be capable of writing code or analyzing a document, but its prompts, tools, memory, and instructions can determine whether it completes the job reliably.
That is the problem Harness² is designed to address. The research framework experiments with improving the system surrounding an AI model, rather than trying to retrain the model itself.
The important distinction: Harness² changes the agent's working setup while keeping the underlying model weights fixed. It is an interesting research direction, but it should not be confused with a fully autonomous AI that rewrites its own neural network or guarantees better results on every task.
Harness² focuses on improving the instructions and tools around an AI model, not changing its trained weights.
What Is Harness²?
Harness², pronounced “Harness squared,” is a framework for recursively improving AI agent harnesses in an open-world setting. A harness is the collection of instructions, tools, memory, guardrails, skills, and orchestration that lets a base model act like an agent.
The researchers published the paper “Harness²: Recursive Agent Harnessing for an Open World” on October 9, 2026. Its central idea is that an agent's performance can be improved by refining the system around the model, even when the model itself remains unchanged.
This matters because changing the model is not always practical. Developers may have to work with a fixed model, a specific cloud provider, or an approved deployment, leaving the harness as a more flexible place to experiment.
How Harness² Works: Two Levels of Recursion
Harness² connects two improvement loops. The first revises the harness for the task currently being attempted; the second retains evidence-supported lessons from those revisions to guide later improvements.
Level 1: Improve the Current Task's Harness
- Propose: Generate possible edits to the current harness, such as changing tool guidance or task instructions.
- Probe: Run candidate versions under comparable conditions and inspect differences in their behavior.
- Compose: Build a revised harness using changes supported by the execution evidence.
Level 2: Improve Future Harnessing
The system reflects on the changes that were adopted and the evidence behind them. It updates a persistent improvement harness so future refinement can use lessons about what worked, where it worked, and why.
The distinction is subtle but important. Harness² does not simply copy the previous task's final instructions into the next task; its design aims to carry forward reusable lessons from the improvement process.
What Can the Framework Actually Change?
The project identifies eight editable components around the base model. These components shape how an agent interprets a task, chooses tools, stores information, delegates work, and executes actions.
The Eight Harness Components
- System prompt: The main behavioral instructions.
- Guardrails: Rules and constraints around agent behavior.
- Memory: Information retained to support future steps.
- Tool guidance: Instructions for selecting and using tools.
- Subagents: Components that delegate work to other agents.
- Skills: Reusable procedures or specialized capabilities.
- Scripts: Executable routines used inside the workflow.
- Plugins: Extensions and middleware that influence the tool loop.
This makes Harness² relevant to developers who already use coding agents or other tool-enabled AI systems. Its purpose is not to create a new foundation model; it is to investigate how much performance can be gained by improving the operational design around an existing one.
What Do the Harness² Benchmark Results Show?
The paper evaluates Harness² across three professional benchmarks and four model–harness configurations. The authors report that a single improvement step raised performance over the corresponding base harnesses, with additional gains as the task-level recursion budget increased.
These are the study's reported benchmark gains, not a promise of equivalent improvements in a production application. The measurements also use different benchmarks and metrics, so they should not be treated as directly comparable scores.
The work evaluates GLM-5 and Gemini 3.5 Flash across configurations using OpenCode and Codex executors. It is notable that improvements are reported with the model weights held fixed, but independent reproduction and testing on different real-world workloads would provide stronger evidence about generality.
Parallel vs. Sequential Recursion
Harness² supports two ways to spend its task-level refinement budget. Parallel recursion explores several candidate changes and combines evidence from their results, while sequential recursion applies a series of improvements one after another.
Parallel Recursion
- Explores multiple candidate harnesses at once.
- Can compare broad alternatives using shared evidence.
- May require more concurrent executions and resources.
Sequential Recursion
- Carries each refined harness into the next step.
- Lets changes accumulate over successive iterations.
- Can take longer as the refinement chain grows.
The project summarizes the trade-off simply: parallel recursion explores wider, while sequential recursion refines deeper. The best option depends on the task, available compute, evaluation budget, and how much repeatable improvement the developer needs.
The Overlooked Problem: Evaluation Can Be Contaminated
The framework's benchmark setup raises a practical issue that deserves attention. Its own documentation warns that executor network access is unrestricted and that Codex runs with its sandbox disabled; it also notes that public benchmark rubrics may be accessible online.
That creates a risk that an agent could reach evaluation material it should not see. If an experiment allows access to benchmark answers or grading criteria, the resulting score may not faithfully measure the intended capability.
Before Running Your Own Benchmarks
Follow the project's network-isolation guidance and prevent agents from accessing answer keys, hidden tests, or grading rubrics. Keep task selection, model configuration, executor, recursion budget, and evaluation settings consistent between baseline and refined runs.
This matters beyond Harness². A recursive optimizer can appear to improve a system by exploiting the evaluation environment instead of improving the underlying workflow. Reproducible settings and careful isolation are essential if benchmark gains are to mean anything.
How Developers Can Try Harness²
The repository provides a local demo that runs both recursion modes with deterministic editors and real Python executions without requiring model credentials. Model-backed benchmark runs require additional setup and can incur API costs.
The documented environment includes Linux, Python 3.12 or 3.13, and the uv package manager. Depending on the selected benchmark, developers may also need Node.js 20 or later, Google Cloud CLI authentication, Docker, Pandoc, and Poppler.
Start with the project's README and setup guide, run the local demo, and then choose one supported benchmark—JobBench, LAB, or WorkBuddy-Bench—before attempting larger model-backed experiments.
Watch the Harness² Project Overview
The following video is linked from the Harness² project repository. It is a project-provided overview, not a Google corporate announcement or an independent evaluation of the reported benchmark results.
Source: Harness² project repository, which also contains the research paper, setup instructions, benchmark documentation, and source code.
Master the Google Gemini Ecosystem
While Google Research's Harness² framework is built for developers to refine complex AI agent workflows, Google's flagship Gemini models are already transforming everyday productivity. Read our Complete Google Gemini Guide to understand the latest model tiers, learn how to integrate Gemini into your daily workflow, and unlock its most powerful reasoning features.
Read the Complete Google Gemini Guide →Sources checked for this article:
Harness²: Recursive Agent Harnessing for an Open World — arXiv — paper abstract, methodology, authors, and reported benchmark results.
Harness² GitHub Repository — project README, editable harness components, installation guidance, video overview, and the project's disclaimer.
Harness² Experiment Guide — recursion modes, budget settings, benchmark reproducibility, and network-access considerations.
MarkTechPost: Google Harness² Recursive Agent Harnessing Framework — the reference article for this report.
Frequently Asked Questions About Harness²
What is Harness² in AI?
Harness² is a research framework for recursively improving an AI agent's harness, including its prompts, tools, memory, skills, and orchestration, while keeping the underlying model weights fixed.
Does Harness² retrain or modify the AI model?
No. The framework focuses on editing and improving the surrounding harness. Its paper describes the model weights as fixed during the recursive harness-improvement process.
What benchmark improvements did Harness² report?
The authors report gains of up to 11.5 points on WorkBuddy-Bench, 4.5 points on JobBench, and 11.8 percentage points on LAB's partial pass rate. These are research results, not guaranteed improvements in every deployment.
Is Harness² an officially supported Google product?
The project is published in the google-research GitHub organization, and the paper includes authors with Google affiliations. However, its README explicitly states that it is not an officially supported Google product.
Can developers run Harness² locally?
Yes. The repository documents a local demo using deterministic editors and real Python executions that does not require model credentials. Running model-backed benchmarks requires additional dependencies and may incur API costs.
No comments:
Post a Comment