Harness² (Harness-squared) is an open-source, plug-and-play recursive agent harnessing framework from Northwestern University and Google Cloud AI Research. It automatically evolves an LLM agent's execution harness — the prompts, tools, and scaffolding around the model — rather than retraining the model itself. It uses two levels of recursion: task-level (refine the harness for the current task) and harnessing-level (extract reusable experience for future tasks).

How does Harness² improve agents without ground-truth verifiers?

Open-world tasks are novel at test time, so there's no reliable ground-truth checker to guide harness edits. Harness² solves this with a contrastive 'Propose-Probe-Compose' step: it proposes candidate harness edits, probes them against each other contrastively to judge which is better without an oracle, and composes the winning changes. This can be scaled with parallel or sequential recursion budgets.

What results did Harness² achieve?

Across three professional benchmarks and four model-harness configurations, a single step consistently improved GLM-5 and Gemini 3.5 Flash over their base harnesses — up to 11.5 points on WorkBuddy-Bench, 4.5 points on JobBench, and 11.8 percentage points on LAB — with further gains as the task-level recursion budget increases. All with frozen model weights.

Where can I get Harness²?

The code is open-sourced at github.com/google-research/harness2, with a project page at harness2.github.io and the paper at arXiv:2610.14224. It's designed to be plug-and-play on top of existing agent harnesses.

Harness²: Google's Recursive Agent Harnessing Improves Frozen Models by Up to 11.8 Points

By Prahlad Menon Published 2026-10-19 4 min read

There are two ways to make an AI agent smarter: change the model, or change everything around the model. Retraining weights is expensive, slow, and often out of reach. But the harness — the prompts, tools, retries, and scaffolding that wrap the model — is software you control. Harness², from Northwestern University and Google Cloud AI Research, makes a compelling case that the harness is where a lot of the untapped performance actually lives.

And it gets there without touching a single weight.

The Problem: Self-Improvement Breaks in the Open World

Recursive self-improvement (RSI) — an agent iteratively rewriting its own scaffolding — is a seductive idea. We’ve written about it from several angles: Anthropic’s claim that Claude writes 80% of its own code, SIA updating its own weights, and Meta-Harness, the agent that rewrites its own scaffolding. The dream is an agent that gets better the more it works.

The paper identifies two reasons RSI tends to fall apart in the real (open) world:

No ground-truth verifier. Real tasks are unseen at design time and novel at test time. Without an oracle telling you whether an edit helped, online self-improvement can happily optimize itself into nonsense.
It doesn’t generalize. Most RSI is painfully task-specific — tune the harness for task A, learn nothing transferable for task B.

The Fix: Two Levels of Recursion

Harness² (“Harness-squared”) answers both with two connected recursion loops.

Task-level recursion refines the harness for the current task using a contrastive Propose-Probe-Compose step:

Propose candidate edits to the harness.
Probe them contrastively — compare candidates against each other to infer which is better, sidestepping the missing ground-truth verifier entirely.
Compose the winning changes into an improved harness.

This loop can be scaled with a recursion budget, run either in parallel or sequentially, and performance keeps climbing as you spend more of it.

Harnessing-level recursion is the part that makes it generalize: it extracts experience from those task-level edits and folds it into a continual improvement harness, so lessons learned on one task make the agent better at future, never-seen tasks. That’s the “²” — recursion on the task, and recursion on the harnessing process itself.

Crucially, it’s plug-and-play: Harness² sits on top of an existing agent harness rather than replacing it.

The Numbers

Across three professional benchmarks and four model–harness configurations, a single step of Harness² consistently beat the base harnesses — with frozen weights:

+11.5 points on WorkBuddy-Bench
+4.5 points on JobBench
+11.8 percentage points on LAB

And these are the single-step gains — the paper reports further improvement as the task-level recursion budget grows. Both GLM-5 and Gemini 3.5 Flash benefited, which suggests the method isn’t overfit to one model family.

Why This Matters

The quiet thesis here lines up with something we keep coming back to: for a lot of real work, you probably don’t need a bigger model — you need a better harness. Superpowers made coding agents act like senior developers purely through scaffolding. Everything Claude Code cut costs 60% the same way. Harness² formalizes that intuition into a recursive, verifier-free procedure and shows double-digit gains on professional benchmarks — all at inference time, no fine-tuning, no GPU bill.

The verifier-free contrastive probing is the genuinely clever bit. “How do you know an edit helped when there’s no answer key?” has been the Achilles’ heel of open-world self-improvement. Answering it by comparison instead of absolute scoring is a neat trick that others will likely borrow.

It’s open-source, it’s plug-and-play, and it targets the layer most teams can actually change. If you’re running agents in production, this is one worth reading closely.

Paper: arXiv:2610.14224 · Code: github.com/google-research/harness2 · Project page: harness2.github.io