Here’s something you may have noticed. You ask Claude a coding question in Claude.ai and get a decent answer. You ask the same thing in Claude Code and it goes and reads your files, runs the tests, fixes two things and tells you what it changed. Or you pick the same model inside GitHub Copilot and it feels different again.
Same model. So where does the difference live?
In the last article we split the model from the application. The model is the trained LLM, and the application is what someone built around it. “The application” is still a big box, though. Today I want to open it and give the parts names you’ll keep hearing: model, harness, agent, product.
The model you already know. It takes input, returns output, and remembers nothing between calls.
The harness is the word that’s new for most people, and it’s the most useful one. Different companies describe it slightly differently, so let me show you a few.
LangChain puts it most bluntly. In their post The Anatomy of an Agent Harness they write “Agent = Model + Harness”, and “if you’re not the model, you’re the harness”. A harness, for them, is every piece of code, configuration and execution logic that isn’t the model itself.
Microsoft’s Agent Framework docs say an agent harness is “the runtime scaffolding that turns a language model into an agent that can perform work”. It drives the model and tool calls, manages conversation state and context, applies approval policies, and keeps the agent moving through a multistep task.
OpenAI, in a post about Codex, lists what a capable agent needs: a way to understand the task, keep context over time, call tools, show progress, handle failures, ask a human for approval when needed, and return a useful result. “That surrounding execution system is the harness.”
Three companies, the same idea. For me it comes down to this. The harness is the code that sits between you and the model and decides what actually happens. It writes the system prompt you never see. It decides which tools the model is offered. It decides what goes into the context on each call and what gets trimmed. And when the model asks to run a command or edit a file, the harness is what runs it, or refuses to.
That last part matters. The model proposes, the harness decides what executes. A model can’t delete your files. It can only produce text that asks for it. Whether that request becomes an action is a harness decision, which is also why permissions and approvals live there and not in the prompt.
An agent is the model and the harness together, working in a loop. Anthropic’s Building effective agents describes agents as “typically just LLMs using tools based on environmental feedback in a loop”. OpenAI’s
Agents SDK says an agent is “a large language model (LLM) configured with instructions, tools, and optional runtime behavior”. The wording differs. The shape is the same. Model, plus instructions and tools, plus something running the loop.
The product is the word I use for the thing you actually sign up for. Claude Code, ChatGPT, GitHub Copilot. It has a harness inside it, but it also has accounts, billing, a UI, settings, plans. This one is my own working word, so don’t expect a formal definition from any vendor. The same harness can turn up in more than one product. Anthropic’s Agent SDK gives you “the same tools, agent loop, and context management that power Claude Code” as a library. Same harness, and you build your own product around it.
Where does the model sit, and what is wrapped around it?
Here is the whole thing in one table.
| Word | Plainly | Example |
|---|---|---|
| Model | the trained LLM, input in and output out | the Claude models, the GPT models |
| Harness | everything around the model that decides what happens | Claude Code’s loop, tools and context handling |
| Agent | model + harness running in a loop toward a goal | Claude Code fixing a failing test |
| Product | what you sign up for and pay for | Claude Code, ChatGPT, GitHub Copilot |
So back to the question. Why does the same model feel different in two products?
Because most of what you experience is the harness. Two products can send the same model a different system prompt, different tools, a different slice of your history, and a different number of chances to try again. LangChain showed this in a Terminal Bench experiment. They kept the model fixed, changed only the prompts, tools and middleware, and moved their coding agent from outside the top 30 to the top 5.
There’s an honest limit here. The model and harness aren’t fully independent. LangChain’s anatomy post points out that useful harness features end up in the training of the next models, so models get tuned to the harness they were trained in. Put a model in a different harness and it can behave better or worse, and you won’t know until you test it.
One more pair of words you’ll hear a lot: workflow and agent.
Anthropic draws the line clearly. Workflows are “systems where LLMs and tools are orchestrated through predefined code paths”. Agents are “systems where LLMs dynamically direct their own processes and tool usage”. You know this difference already. A workflow is a pipeline you wrote. Step one, step two, maybe a branch. The model fills in some of the steps, but your code decides the order. An agent is control flow decided at runtime. The model looks at the result and chooses what to do next.
Which should you use? Microsoft’s Agent Framework overview has a simple rule of thumb. Use an agent when the task is open-ended or conversational and needs autonomous tool use and planning. Use a workflow when the process has well-defined steps and you need explicit control over the order. And then my favourite line in their docs: “If you can write a function to handle the task, do that instead of using an AI agent.”
Anthropic says much the same. Start with the simplest thing that works, and add complexity only when it clearly improves results. Agentic systems often trade latency and cost for better results. If your process is known and repeatable, like classifying a ticket and routing it, a workflow is cheaper, faster and much easier to debug. Reach for an agent when you genuinely can’t predict the steps.
What does all of this mean for you at the end of the day? When someone says “agent”, ask two questions. Which model? And what’s the harness, meaning what loop, what tools, what context, and who decides what runs? Most of the interesting engineering, and most of the risk, is in the second answer. Up to now you’ve been using someone else’s harness. Later in this series you’ll build your own.
If you want to see how I think about the harness and the governance layer on top of it, my post The Two Layers That Decide Whether Your Agent Survives goes deeper.
Next, we’ll follow a single message from the moment you hit Enter to the model and back.
