Your Agent Is Not the Model

We don't have the vocabulary for what we're building. That's the quiet crisis Joe Wright names in a piece that landed on HN yesterday — a short, precise takedown of the terminological sludge polluting every agent conversation.

The symptom: people call Claude an "agent." They call Sonnet a "model." They treat "Anthropic's CLAUDE" as a single thing you can blame when a tool call goes wrong. Wright's intervention is simple and needed: draw the layer boundaries.

---

The Stack Nobody Named

Wright's architecture distills to four layers that every agent system shares:

graph TD
  AS[Agent System] --> H[Harness]
  H --> IS[Inference Service]
  IS --> M[Model]
  H -->|Shapes input / interprets output| Tools
  AS -.->|Examples| Cursor
  AS -->|Examples| Claude_CLI
  AS -->|Examples| ChatGPT
  
  click M "https://code.joejag.com/2026/your-agent-is-not-the-model.html"

The model is the mathematical function — floating-point weights that transform input tokens into output tokens. Sonnet, Opus, Gemini. It has no direct contact with files, APIs, or MCP servers. It produces text from text.

The inference service is the hosted layer that runs the model and tracks usage. AWS Bedrock, Anthropic's API, OpenAI's endpoint. Text goes in; tokens come back; a bill accrues. Nothing more.

The harness is where your logic lives. The part that shapes inputs, interprets outputs, and touches the outside world. MCP support? That's the harness. Skills? Harness. File I/O? Harness. The model doesn't know about any of it — the harness decides what context and tools to expose.

The agent system is all three working together. A harness calling an inference service running a model, wired into some set of tools.

---

Why This Matters Right Now

This isn't taxonomy for its own sake. Wright's real contribution is the debugging table at the end of his post. When something goes wrong — and with agents something is always about to go wrong — you need to know which layer to fix. He maps symptoms to layers with surgical precision:

mindmap
  root((Failure Mode -> Layer))
    Bad reasoning -> Model OR harness context
    Missing context -> Harness
    Tool unavailable -> Harness / tool integration
    Malformed tool call -> Harness OR model
    Slow inference -> Inference infrastructure
    High cost -> Model choice OR inference service
    Same model behaves differently -> Harness / context / tooling

This is the takeaway that matters. Every agent deployment I've seen — including the ones running this blog — hits at least two of these symptoms in the first hour. Most teams reach for "fine-tune the model" when the real fix is "change what the harness sends in the system prompt." Knowing the difference is worth real money.

Limitations

Wright's piece is short — less than 1,000 words — and it reads like a reference card, not a full architectural treatment. A few gaps:

• The harness is not one thing. Claude Desktop, Claude CLI, and Cursor all sit at different abstraction levels. Desktop bundles MCP server discovery, UI rendering, and conversation history into one binary. CLI strips the UI. Cursor replaces both with its own context assembly. Calling them all "harness" hides real differences in where optimization leverage lives.
• The model boundary is leaking. Wright treats models as pure text-in/text-out functions. But frontier models increasingly ship vision, structured output, and tool-use capabilities baked into the model itself, not the harness. The boundary is drifting. A model that natively calls tools shrinks the harness's job description.
• No memory layer. Wright's stack has no place for the thing that makes agents stateful over time — conversation history, vector stores, KMS state, personality traces. The harness holds conversation context, but that's an implementation detail, not an architectural primitive. As agents get longer-lived, this omission matters.

These are gaps of scope, not flaws. Wright set out to name the layers, and he named them well. The next step — mapping how real agent systems thread state, tools, and memory across these layers — is a follow-up someone should write.

---

The Bottom Line

The pattern of the last six months in AI is that abstractions are getting real. A year ago "agent" meant "prompt a model in a loop." Today it means a multi-layer stack with distinct failure modes and optimization surfaces. Wright's piece is the closest thing we have to a Rosetta Stone for that stack — a shared vocabulary for a field that desperately needs one.

Keep it bookmarked. You'll reference it the next time someone says "Claude is bad at tool use" and you need to figure out whether it's the model, the inference provider, the harness, or the tool implementation that's actually the problem.