Agent = Model + Harness: the harness decides what your model can do

An agent is not a stronger model. It is what emerges when model capability couples with an execution harness, and getting that distinction right is the starting point for every decision in agent engineering.

01 / The core formula: Agent = Model + Harness

An agent is the working entity you get when a model meets a harness. A harness on its own is just infrastructure. Add a model and you have an agent.

Two terms get conflated here, so separate them first:

• Framework — a parts library for building agents, LangChain being the obvious example. Components, nothing assembled.

• Harness — an assembled system with defaults and a complete runtime: everything that wraps a model, meaning context, tools, the loop, evaluation and sandbox.

The division of labour then reads like this:

• Model supplies raw intelligence. It handles text, emits tokens, reasons. A bare model is stateless: no tools, no memory, no file reads or writes, no command execution.

• Harness is everything else: context management, tool-call interfaces, memory mechanisms, sandboxed execution, permission control, evaluation hooks, sub-agent orchestration. It is what turns a conversational engine into something that does work.

The industry has converged on Agent = Model + Harness. Watch out for the reversed formulation, Harness = Model + Agent, which is simply wrong: the harness exists before the agent as a runtime shell, not as a component inferred backwards from one.

The formula is also too flat, and flatness hides the real tension between the three. A nested structure describes it better:

┌─────────────────────────────────────────┐
│                  Agent                  │
│   ┌───────────────┐   ┌───────────────┐ │
│   │     Model     │   │    Harness    │ │
│   │  (cognition)  │ ← │   (runtime)   │ │
│   └───────────────┘   └───────────────┘ │
│           ▲                   ▲         │
│           └────── loop ───────┘         │
└─────────────────────────────────────────┘

Model and Harness do not sit side by side and add up. They couple, as core and shell. The agent is the acting subject that coupling produces while it runs.

02 / Ontological status of the three

Put the three side by side and the differences are hard to miss:

• Model — a probability function at bottom. It answers "what could this be". Stateless, invoked. Comparable to a CPU.

• Harness — a control system. It answers "what is allowed, and how is it judged". Stateful, always running. Comparable to an operating system.

• Agent — an acting subject. It answers "what actually got done". Has a trajectory, exists emergently. Comparable to a running program.

Potential, structure, kinetic — that is the compact version:

• Model is potential energy — a vast field of possibility that cannot discharge itself in any direction.

• Harness is the structure that channels it — deciding which possibilities get activated, permitted, recorded and judged.

• Agent is kinetic energy — the actual behaviour released once potential discharges through that structure.

03 / Three asymmetric relations

1. Model to Harness — capability supplied, controllability not. The model delivers comprehension, reasoning and generation, and it carries three fatal gaps:

• Stateless: every call starts fresh, with no memory of the last second.

• Bodiless: it cannot read or write files, run commands or reach the network.

• No boundary sense: it does not know where to stop or what is off limits.

The model is powerful and blind. It is high-energy fuel that cannot build its own engine.

1. Harness to Model — constraining and enabling at the same time. What the harness does to the model runs in both directions:

• Enabling, so the model can do what it cannot do alone: injecting context gives it memory, exposing tools gives it hands, running the loop gives it sustained action.

• Constraining, so the model cannot do what it should not: structured output narrows its expressive space. Permission boundaries narrow its range of action. Step and timeout caps bound resource use. Evaluation assertions stop it from declaring success on its own say-so.

This is the deepest thing about a harness: it is the model's exoskeleton and its cage simultaneously. Without it the model is powerless; without it the model also runs wild.

1. Model plus Harness to Agent — not addition, coupled emergence. The substance of an agent is a loop:

Harness assembles context → Model produces a decision → Harness executes and observes
→ Harness writes the result back into context → Model decides again → ...

Inside that loop the model contributes direction and the harness contributes memory, boundaries and feedback. The continuous goal-directed behaviour that emerges from the coupling is what we call an agent. An agent is a verb, not a noun — it is the event of a model running inside a harness.

04 / The one-line essence

The model is the source of intelligence, the harness is its container and its judge, and the agent is the behaviour that emerges once intelligence circulates inside that container.

One level tighter: the model supplies can, the harness supplies may, and an agent is can turning into does, continuously, inside the bounds of may.

05 / Why this distinction is fundamental

It explains why the same model produces wildly different agent results. Performance does not track how strong the model is in isolation. It tracks four things: what the harness shows the model (context quality), what it lets the model do (tool design), how it decides whether the work was any good (evaluation feedback), and how it keeps the model from drifting (constraint mechanisms). The model decides the ceiling; the harness decides how much of that ceiling you reach.

It explains why stronger models make the harness more important, not less. The intuition says that as models improve the scaffolding around them can get simpler. The opposite happens:

• More capable means more it can do, so permission boundaries matter more.

• More capable means longer action chains, so memory and trajectory management matter more.

• More capable means more initiative you did not ask for, so evaluation and rollback matter more.

• More capable means better tool use, so interface design is worth more.

Growing model capability moves the bottleneck from intelligence to controllability, and controllability is the harness's territory.

It explains what agent engineering actually engineers. Agent engineering is harness engineering: prompts are the context layer, tool definitions the interface layer, the loop the control layer, evaluation the judge layer, the sandbox the safety layer. The model is bought or trained. The harness is what your engineers actually build. An agent is the output of harness engineering, not a property of the model.

06 / After RSI: who is actually in control

Give an agent recursive self-improvement (RSI) and the question escalates: who is the controlling subject? RSI takes an agent from being able to act to being able to improve how it acts. Control here is not a single point. It is a system-level loop.

Four levels, which are easy to collapse into each other:

• Intelligence is a capability: explaining, reasoning, generating.

• Model is the carrier of that capability, the core engine.

• Harness is the closed-loop infrastructure that connects capability to the real world.

• Agent is the system subject that perceives, decides, acts, reflects and improves, continuously, inside an environment.

In one line: intelligence is a capability; an agent is that capability organized into an acting system. Intelligence plus goal management, tools, memory and feedback loops is what equals an agent.

The RSI meta-loop takes an agent past executing tasks. It recursively improves the way it executes them: observe its own performance, diagnose the bottleneck, modify its skills (prompt, workflow, tool policy, memory policy), then redeploy and continue, picking up state updates, environment feedback and log observations. A second ring closes on top of perceive-decide-act: perceive-decide-improve.

So who controls it?

• Not the model alone. The model is a cognitive engine, a generator of decisions. It produces judgements, but it generally holds no complete state and carries no execution responsibility.

• Not the harness alone. The harness is nervous system and operating system in one. It schedules and constrains, but it is not the source of intelligent judgement.

• The agent is the functional subject. As a system-level subject it draws on model capability, organizes execution through the harness, and acts on the results.

• Control is systemic; the subject is the agent. The model is the cognitive core and the harness is the execution framework.

07 / Final summary

• Model, the intelligence core — supplies possibility, but with no direction, no memory and no body.

• Harness, the runtime shell — supplies direction, memory, a body, boundaries and a judge.

• Agent, the acting subject — the goal-directed behaviour that emerges once a model runs in a loop inside a harness.

Put together: the model is can, the harness is may, and the agent is can becoming does inside may.

So the final formula is Agent = Model × Harness, multiplication rather than addition. The sign carries two claims: if either side is zero there is no agent at all, and if either side grows the agent is amplified — but the harness decides the direction of that amplification.

Even after RSI, saying "agent = intelligence" is still wrong. The accurate phrasing is: an agent is an intelligent system that is organized, executable, feedback-capable and self-improving. It is not controlled by the model or by the harness in isolation. The agent, as a whole, is the subject that acts outward.

Further reading: the Agentic field page on Y, and the Agentic track on the Tech Radar.