The correct answer is the combined system of **LLM plus runtime plus tools** working together. People often say "the agent" and point at the model, but that is not quite right.
Think about what the LLM actually does. It reads the current situation and produces text. When it wants to use a tool, it does not run anything itself. It emits a structured message that says "please call the search tool with this query." That message is just words until something else acts on it.
That something else is the runtime, also called the harness. The runtime reads the model's request, actually invokes the tool, captures the result, and feeds it back into the next model call. It also keeps track of the running state and enforces limits like a maximum step count or a cost cap.
So the model is the brain that decides, and the runtime is the body that acts. Tools are what the body can reach. Remove any one piece and you no longer have an agent. The model alone is a chatbot. The runtime alone has nothing to decide. The agent is the whole loop.
The agent is the **whole system**: the LLM, the runtime that drives the loop, and the tools it can reach. Calling the model alone "the agent" is the single most common misconception.
The split matters because the two halves have different jobs. The LLM is the brain. It reads the current state and decides the next action. It does this by emitting text, either a final answer or a structured tool-use request. Crucially, the model cannot execute anything. A tool-use block is just a string until something acts on it.
The runtime, sometimes called the harness, is that something. It parses the tool request, actually invokes the tool, captures the result, and appends it to the state for the next turn. It also manages the loop itself. It enforces the step budget, the cost cap, and the timeout, and it handles tool errors so a bad call does not crash the run.
So decision and execution are cleanly separated. The model proposes, the runtime disposes. Removing either one breaks agency. A model with no runtime is a chatbot. A runtime with no model has nothing to decide. The agent is the loop they form together.
Quick reference
TL;DR
The agent is the whole system: the LLM decides actions, but the runtime executes the tools, manages state, and enforces limits. The model itself runs no code.
Think of a film director and a film crew. The director decides what should happen next, calls out the shot, and reacts to what they see on the monitor. But the director does not personally move the camera, adjust the lights, or roll the film. The crew does that. The director without a crew is just someone talking; the crew without a director has nobody deciding what to shoot. The finished scene is the whole production working together. An LLM agent is the same. The model is the director: it reads the situation and decides the next move. The runtime is the crew: it actually calls the tool, runs the code, saves the result, and stops the shoot when the budget runs out. Neither one alone is the agent. The agent is the director and crew, acting as a single system.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Explaining the split to a non-technical stakeholder who only needs the outcome. The brain versus runtime detail adds confusion when the audience only cares about what the agent achieves.
A pure single-shot LLM call with no tools and no loop in the design. There is no runtime executing actions, so the agent framing does not apply to a plain completion.
Discussing model capability limits like reasoning quality or knowledge cutoff. Those are properties of the LLM itself, and the runtime split does not change what the model knows.
Quick scan · 2–4 min
Everything important, quickly.
State that the agent is the whole system, then separate the LLM as the decision maker from the runtime as the executor. Explain what the model emits, what the runtime owns, where state lives, and why the split is a security and reliability boundary.
Real-world examples
Real products, models, and research that use this idea.
1Anthropic's computer use feature: Claude Opus 4.7 decides the next click or keystroke, but the harness takes the screenshot, executes the action on the desktop, and loops the result back.
2LangGraph runs the loop as a typed state graph. The model node decides; the framework executes tools, persists state, and enforces the recursion limit that caps step count.
3The OpenAI and Anthropic SDKs return a tool-use block from the model that your own code must execute. The SDK never runs the function for you; the runtime you write does.
4Cursor and Cline coding agents: GPT-5.5 or Claude proposes a file edit, but the editor runtime applies the diff, runs the tests, and feeds the results back into the next turn.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhy is the brain and runtime split a useful security boundary, not just a tidy abstraction?
Sign in or go Pro to see the approach for this follow-up.
QIf the model is stateless across calls, how does an agent remember what it did three turns ago?
Sign in or go Pro to see the approach for this follow-up.
QWhat stops a confused model from looping forever, and which component enforces it?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Calling the LLM alone the agent. The model only emits a tool-use request as text. The runtime is what actually invokes the tool, manages state, and enforces budgets.