M XYZ
EN / PT
← Back to Journal
EN Essay · · 8 min read

Why the Harness Matters More Than the Model

From the tiny alien inside Rosenberg's head to Russian nesting dolls, multi-model subagents, and why production reliability is engineered in the harness rather than inside the weights.

Written by
#harness #ai-engineering #agent-orchestration #systems
Impasto painting of molten amber currents flowing through dark teal monoliths

Every few months a stronger frontier model arrives and resets the ceiling of what a single completion can do. Yet when teams move from a weekend prototype to a system that runs unsupervised on real repositories, most failures have surprisingly little to do with raw intelligence.

They happen in the harness: the runtime layer that decides what the agent sees, which tools it can invoke, how errors are formatted back into context, and when execution stops.

What on Earth is a harness?

If you want an intuitive picture of an AI harness, think back to the 1997 movie Men in Black. Halfway through the film, Agents J and K stand over the body of a jeweler named Rosenberg on a morgue table. Suddenly, his face swings open like a hinged door. Inside the skull sits a tiny, fragile Arquillian alien perched in a miniature cockpit, steering an entire human-sized mechanical body with levers, foot pedals, and small glowing monitors.

A raw language model is that tiny Arquillian.

On its own, a model has no hands, no eyes, no filesystem, and no concept of whether a test suite just passed or failed. It only receives a stream of tokens and predicts the next ones. Everything that lets that tiny intelligence act in the real world (the cockpit monitors that assemble its context window, the levers that expose tools, the safety locks that govern permissions and sandboxes, and the loop that feeds outputs back inside) is the harness.

Another way to picture it is a Russian Matryoshka doll. At the innermost core sits the raw model. Around it fits a shell of instructions, persona, and memory. Around that sits the tool runtime and execution loop. Around that sits workspace isolation, telemetry, and guardrails. Each outer shell constrains and amplifies the inner one.

Painterly illustration of an opened Russian Matryoshka doll revealing progressively smaller nesting dolls around a glowing amber-and-cyan core
A harness works like a Matryoshka doll: nested shells of context, tools, and guardrails turning a raw model at the core into a capable actor.

For a single chat turn, you barely notice the shells. For a long-running coding task, the shells are the product.

And that brings us to the real inflection point: what happens when you stop putting one tiny pilot inside one mechanical body, and instead coordinate several distinct models alongside a pleiad of subagents, each working inside its own thread?

The role of harnesses in orchestration

Looking back at my own path with AI, from the early GPT-3 days to today, my biggest leap was realizing that I could build genuinely large software projects by orchestrating agents and subagents. Just two years ago, before most of today’s harnesses existed, I improvised a painting game for my daughter in 25 minutes. It was rough, duct-taped, and gloriously imperfect. Back then I could barely imagine we would have the tooling we work with today, and that was only two years ago.

Moving from one improvised loop to a constellation of parallel subagents changes what a harness has to be. It stops being a single exo-suit and becomes the nervous system, and the conductor’s score, for an entire ensemble.

Different models have genuinely different temperaments. One model may excel at deep architectural planning or subtle code review; another may be dramatically faster and cheaper for broad codebase reconnaissance, mechanical refactors, or high-volume log triage. A naive wrapper forces every subtask through the same brain and dumps every intermediate output into one bloated conversation window.

A well-designed orchestration harness solves four hard problems at once:

  1. Context hygiene across threads. When a subagent explores thirty files to answer one question, its messy search trajectory stays inside its own thread. Only the distilled findings return to the coordinator’s cockpit, protecting the main context window from noise and drift.
  2. Heterogeneous model routing. The harness lets the system match the right model (and reasoning effort) to the right slice of work, instead of paying frontier latency and cost for every trivial step.
  3. Boundary enforcement. When multiple subagents run concurrently, the harness decides who can read, who can write, which tools are exposed, and which git worktree or sandbox each worker owns so parallel edits never silently collide.
  4. Structured handoffs. Rather than passing vague prose between agents, the harness enforces clear contracts: what a child agent received, what files or artifacts it produced, what checks ran, and whether it is genuinely done or blocked.

Without a strong harness, adding more agents does not multiply capability. It multiplies entropy.

The pursuit of the perfect harness

Because teams have realized how much leverage lives outside the weights, the ecosystem has exploded into an active race to build the ideal harness. Look around the market today and you can already see distinct philosophies taking shape:

  • Terminal-first native harnesses like Claude Code and OpenAI Codex CLI bet on tight vertical co-design between frontier models and their execution loops. They live directly inside the developer’s shell, embracing git workflows, hooks, subagents, standardized repo instructions (AGENTS.md and CLAUDE.md), and the Model Context Protocol (MCP).
  • Editor-native harnesses like Cursor and Cline anchor the loop inside the IDE, bridging fast inline human edits with multi-file composition, explicit planning modes, bring-your-own-key model switching, and background cloud agents.
  • Open, model-agnostic, and sandboxed platforms like OpenCode, Goose, and OpenHands push toward modularity, provider freedom, strict tool governance, and containerized multi-harness execution, letting teams swap underlying models or even plug different execution engines into a unified orchestration layer.

Yet the deeper you work with these tools, the clearer one truth becomes: there is probably no single “perfect” harness.

Every harness encodes sharp architectural tradeoffs. Vertical co-design squeezes uncanny performance out of one model family, while model-agnostic harnesses protect your ability to route across providers as the frontier shifts every quarter. Local execution feels immediate and intimate; containerized cloud sandboxes trade a little immediacy for fearless parallelism and stronger safety boundaries.

What is converging is the connective tissue: open protocols like MCP, portable project conventions, and cleaner separation between the model, the harness loop, and the orchestration layer sitting above them.

That modular seam is also where smaller, sharp-edged harness components start to shine. One concrete example from my own work is Spillway, an experimental MCP proxy and plugin I have been building to tackle a specific failure mode: oversized tool output flooding an agent’s context window. Like a dam spillway, normal tool output passes untouched, while a 5,000-line compiler dump gets capped into a bounded preview that preserves exit codes and file:line diagnostics, diverting the complete original into a recoverable artifact on disk. It is unglamorous plumbing, not a frontier weights breakthrough, yet that is precisely the kind of harness work that keeps long multi-agent runs from drowning in their own noise.

Treating orchestration as systems engineering

Once you step back and look at the Arquillian cockpit, the Matryoshka shells, and a multi-thread constellation of subagents together, something comforting happens: the mysticism fades, and familiar systems engineering comes back into focus.

An agentic workflow is, at its core, . You cannot make the model itself 100% deterministic, nor would you want to, because its flexibility is the whole point. What you can make deterministic is almost everything around it:

  • Explicit concurrency models. Treat parallel subagents the way you treat concurrent workers in any distributed system: isolate mutable state (separate git worktrees or containers), bound fan-out, and avoid hidden shared memory.
  • Contracts at every seam. Define crisp inputs, exit criteria, and verification steps for every delegation boundary. Ambiguity that seems harmless in a single prompt compounds rapidly across a graph of agents.
  • Independent verification. Never rely solely on the agent that wrote a change to declare victory. Pair generative steps with deterministic checks (compilers, typecheckers, test suites, linters) and, where judgment is needed, a separate reviewer thread with fresh context.
  • Backpressure, budgets, and timeouts. Every loop needs clear stopping conditions: token ceilings, bounded tool payloads, wall-clock limits, retry caps, and clean escalation paths back to a human when confidence drops.
  • Observability and replay. Every tool call, handoff, and decision should leave a legible trace. If you cannot inspect why a multi-agent run diverged five minutes after it happened, and replay that trajectory after adjusting the harness, you are operating blind.
export interface OrchestrationContract {
  workerId: string;
  model: string;
  workspace: 'inherit' | 'worktree' | 'sandbox';
  scope: string[];
  doneWhen: string;
  maxTurns: number;
  verifiedBy: ('typecheck' | 'tests' | 'independent-review')[];
}

Frontier models will keep getting faster, sharper, and more surprising. That part of the stack moves like weather.

The durable advantage belongs to the engineers who treat the harness, and the orchestration woven through it, as real craft. Good models feel magical. Good harnesses make that magic composable, auditable, and repeatable.