The Harness Is the Model Now

The Harness Is the Model Now

The most important part of a new agent may be the part that is not trained.

Google Research’s Harness² is an open source framework built around a simple split: keep the model frozen, then recursively improve the harness around it. The harness includes the system prompt, guardrails, memory, tool guidance, subagents, skills, scripts, and plugins.

That is more than a clever optimization trick. It is a direct challenge to the habit of treating model weights as the only serious place where capability lives.

A new control loop around an old model

The paper, submitted on October 9, describes two connected loops.

At the task level, Harness² proposes edits to the execution harness, probes those candidates, and composes a successor from the observed results. The paper calls this a contrastive Propose, Probe, Compose step.

At the harnessing level, the system keeps an improvement library. It records the harness changes and experience that survived the current task, then uses that record to guide refinement on later tasks.

The important detail is what the system does not require. The authors target open world tasks where the task is unseen during harness design and where there may be no ground truth verifier available to score every intermediate edit.

Instead of pretending that a universal grader exists, the loop compares executions. That does not make the process automatically reliable, but it gives the improver a signal when the task itself is difficult to verify directly.

The editable surface is bigger than a prompt

The public project site lists eight harness components:

LayerEditable components
Context constructionSystem prompt, guardrails, memory, skills
Tool interfaceTool guidance, scripts
OrchestrationSubagents
Middleware controlPlugins

This is the systems level point. A production agent is not just a model plus a prompt. It is a control plane that decides what enters context, which tools are available, how work is delegated, and what happens between model calls.

Changing that control plane can alter behavior without changing the model checkpoint at all.

The site shows a concrete example: an improved harness adds verification guardrails, a reconciliation skill, and more precise tool guidance to a workbook task. The result is not a smarter model in isolation. It is a better shaped execution loop.

The reported gains are a harness result

The project reports results on WorkBuddy-Bench, JobBench, and LAB across four model and harness configurations. On WorkBuddy with Gemini 3.5 Flash and OpenCode, the published table reports an average score of 72.4 for the base harness, 77.5 after one Harness² improvement step, and 80.8 with parallel recursion at k equals 5.

Those are reported means from the project, not an independent reproduction in this article. The project site says the WorkBuddy result covers code, web, and office tasks across three runs. The paper abstract reports gains of up to 11.5 points on WorkBuddy-Bench, 4.5 points on JobBench, and 11.8 percentage points on LAB.

The figures support a narrower claim than the usual model release headline: the same executor can perform differently when the harness changes.

That is exactly why benchmark comparisons that omit the harness are becoming less useful. A score is partly a property of the model, partly a property of the control loop, and partly a property of the evaluator that decides what counts as success.

What common intuition gets wrong

The common intuition is that self-improvement means updating weights.

That is one path, but it is not the only path, and often it is not the safest first path. Weight updates are expensive to inspect and difficult to roll back at the level of one task. Harness edits are more legible. A changed skill, tool policy, or guardrail can be reviewed as an artifact, tested against a regression task, and reverted without replacing the model.

The uncomfortable truth is that harness self-improvement also creates a new supply chain. If an agent can rewrite its prompts, tools, memory policy, scripts, or plugins, then those files become part of the agent’s security boundary.

A poisoned improvement record could make a future task inherit a bad tool instruction. A permissive script could turn a quality improvement into a privilege escalation. A memory entry that looks like experience could actually be an unreviewed policy change.

Recursive optimization does not remove the need for a verifier. It moves the verifier closer to the control plane.

What operators should do

Treat harness changes like code changes, not like ephemeral prompt experiments.

At minimum:

  1. Version every harness component. Keep prompts, skills, tool guidance, scripts, and plugins in reviewable files.
  2. Separate proposal from adoption. Let the improver generate candidates, but require an explicit gate before a candidate becomes the default.
  3. Use task-specific regression tests. A harness that improves a spreadsheet task can silently damage browsing, coding, or security work.
  4. Constrain the improvement library. Record provenance, scope, and the evidence that justified each lesson.
  5. Apply least privilege to scripts and plugins. The editable surface is now executable infrastructure.
  6. Keep rollback cheap. If reverting a harness requires retraining or a fleet-wide model migration, the control loop is too tightly coupled.

The Harness² repository is useful precisely because it makes these pieces visible. Its Apache 2.0 license, example components, benchmark documentation, and implementation provide a concrete object to inspect rather than another promise that an agent will simply learn to do better.

The model is only half the agent

Harness² does not prove that recursive harnessing works for every workload. Its reported benchmarks are evidence for a particular framework, set of tasks, models, and evaluation procedure. The open question is whether improvement libraries remain trustworthy as task distributions broaden and as the harness gains access to more consequential tools.

But the direction is clear.

The next generation of agent systems will be judged less by the frozen model they start with and more by the control loop that surrounds it. The weights provide capability. The harness decides how that capability is exposed, checked, remembered, and allowed to act.

The model is not the whole agent anymore. The harness is where the operational truth lives.

Sources

Keep reading