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 themcontrastively — 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