Google’s open-source Harness² is designed to improve an AI agent without changing the underlying model. It keeps model weights frozen and recursively revises the software harness around them: prompts, guardrails, memory, tools, subagents, skills, scripts and middleware. In reported 2026 evaluations, one refinement step produced gains of up to 11.5 points on WorkBuddy-Bench, 4.5 points on JobBench and 11.8 percentage points in partial pass rate on Harvey’s Legal Agent Benchmark (LAB).
The framework matters because an agent’s performance depends on more than its language model. Harness² treats the surrounding runtime as an editable system that can learn from each task and carry evidence-supported improvements into later, previously unseen tasks.
As an Amazon Associate I earn from qualifying purchases.
What Harness² changes
The project defines a harness as the system around a model that enables it to act as an agent. That includes the instructions it receives, the tools it can call, the memory it retains and the orchestration code that coordinates its work. Harness² is a plug-and-play framework for recursively improving that system in an open world, where tasks were not available when the initial harness was designed.
The model itself remains fixed. Harness² does not fine-tune, retrain or otherwise alter model weights; it changes the runtime scaffolding that determines how the frozen model approaches a task.
#1 Best Overall
The eight editable surfaces
- System prompt: the main behavioral and task instructions.
- Guardrails: constraints that control actions, safety checks and output handling.
- Memory: information retained within or across tasks.
- Tool guidance: instructions for selecting and using available tools.
- Subagents: delegated agents and their coordination rules.
- Skills: reusable capabilities that can be invoked by the agent.
- Scripts: executable helpers used during task completion.
- Middleware plugin: runtime code positioned between the agent and its execution environment.
How the two recursion levels work
Harness² couples two feedback loops. Task-level recursion improves the harness being used on the current task. Harnessing-level recursion updates a persistent improvement harness so that lessons from completed tasks can guide future work.
Task-level refinement
- Start with an execution harness. The agent receives an unseen task and runs with the current prompts, tools, memory and orchestration.
- Propose edits. Editors generate candidate changes to one or more of the eight harness components.
- Probe candidates. Each candidate is executed under matched conditions so its behavioral effect can be compared fairly with the current version.
- Compose supported changes. The system uses behavioral contrasts between runs to keep changes that show evidence of improvement and combine compatible edits.
This Propose–Probe–Compose method is contrastive rather than label-driven. It does not require a ground-truth answer or a task-specific verifier to decide which edit to keep; it compares what the agent did under controlled alternatives.
Harnessing-level learning
Adopted harnesses and the evidence explaining what worked, where it worked and why are stored in a continual-improvement library. That library then conditions proposals on later tasks. The result is not merely a better answer to one prompt, but a mechanism for improving the improvement process itself.
Parallel and sequential recursion
Parallel recursion explores several candidate harnesses concurrently. Sequential recursion applies revisions one after another, allowing each round to build on the previous one. The paper reports that both modes improve as the task-level budget grows. Parallel execution can reduce elapsed time when enough concurrency is available, but it still consumes more total execution and editor computation.
Benchmark results
The 2026 repository release and accompanying preprint evaluate Harness² on WorkBuddy-Bench, JobBench and Harvey’s Legal Agent Benchmark across four executor–harness configurations. The figures below are maximum improvements reported after one Harness² step, relative to the corresponding base harness.
| Benchmark | One-step maximum gain | Parallel-recursion gain in analysis | Metric |
|---|---|---|---|
| WorkBuddy-Bench | 11.5 points | Up to 3.9 points | Benchmark score |
| JobBench | 4.5 points | Up to 4.2 points | Benchmark score |
| Harvey’s Legal Agent Benchmark | 11.8 percentage points | Up to 6.7 percentage points | Partial pass rate |
Longer recursion can add further gains. With recursion budget k=5, Gemini 3.5 Flash running under OpenCode improved over its base by as much as 7.5 points on JobBench and 8.4 points on WorkBuddy-Bench. These are benchmark-specific results, not a universal performance guarantee.
What the ablations reveal
The paper’s component-removal tests indicate that the improvement library, scoping and composition each contribute to the result. Removing the persistent improvement library lowered WorkBuddy-Bench by 3.1 points and JobBench by 1.8 points. Removing scoping lowered the scores by 2.9 and 3.7 points respectively, while removing composition lowered them by 1.6 and 1.9 points.
Recommended Free Tools
Those losses show why Harness² is more than a prompt generator: retaining lessons across tasks, limiting proposals to relevant parts of the harness and combining supported edits are separate parts of the method.
Transfer across models and domains
A harness is not guaranteed to transfer equally well between models or task types. In the reported transfer experiment, a harness refined for Gemini 3.5 Flash improved GLM-5 by 17.3 points on a Code workload. Results for Gemini 3.7 Flash and Opus 4.8 varied by domain, so a harness that helps one model or benchmark should be validated again before being adopted elsewhere.
Installation and available demos
Local, credential-free demonstration
The repository’s local demonstration targets Linux, Python 3.12 and the uv Python project manager. It provides a harness2-demo entry point that runs both parallel and sequential recursion with deterministic editors and real Python executions. This demonstration does not require model credentials, making it suitable for inspecting the recursion mechanics before configuring a model-backed benchmark.
- Use a Linux environment with Python 3.12 installed.
- Install and configure
uvaccording to its project instructions. - Set up the repository’s demo environment and invoke its
harness2-demoentry point. - Run both recursion modes and inspect the candidate edits, probes and composed harness produced by the deterministic editor.
Requirements for model-backed benchmarks
Benchmark runs require Node.js 20 or newer, Google Cloud CLI authentication, configured model IDs and the dependencies specified for each benchmark. LAB additionally requires Pandoc and Poppler. WorkBuddy-Bench additionally requires Docker. Model credentials and these external tools are not needed for the local deterministic demo, but they are required for reproducing model-backed evaluations.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Compute costs and practical limits
Recursive improvement trades additional test-time computation for better scores. Every candidate requires editor and execution work, and larger recursion budgets increase token use even when parallelism reduces wall-clock latency. Teams should therefore measure both score and total test-time tokens, not just the final benchmark result.
Best Value
Harness² is most useful when a team can define a repeatable execution environment, tolerate extra trial runs and preserve lessons that remain valid across tasks. It is less suitable when latency or token budgets leave no room for probing alternatives, or when a reliable task verifier is already available and a simpler optimization loop is sufficient.
Project status and caveats
The reported improvements come from a 2026 preprint and repository release. They should be read as experimental benchmark evidence rather than a promise for every production workload. Transfer varies by model and domain, and parallel recursion increases total computation even when it shortens elapsed time.
The repository states that Harness² is not an officially supported Google product and is not eligible for Google’s Open Source Software Vulnerability Rewards Program. Organizations evaluating it should review the repository’s license, dependency versions, execution isolation and data-handling policies before connecting it to live tools or confidential tasks.
Free tools Windows power users keep installed
One-click scans. No signup required.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
