Assistant vs agent: the core distinction
A chatbot or assistant is reactive. You send a message, it replies, and it waits for your next instruction. It has no goal of its own and takes no action beyond producing text. An agent is different: you give it a goal, and it autonomously plans the steps, takes actions through tools, observes what happened, and repeats until the goal is achieved or it gives up. The two defining ingredients of “agentic” behaviour are multi-step autonomy and the ability to act on the world, not just talk about it.
In short: an assistant answers “How do I book a flight?” An agent, given “book me a flight to Berlin under £200,” would search, compare options, and complete the booking — ideally pausing for your confirmation before spending money.
The four building blocks of an agent
- Planning. The agent decomposes a goal into ordered sub-steps, often by reasoning out loud first (chain-of-thought) before acting.
- Tool use. The model can call external functions — web search, a code runner, a database query, an API — and incorporate the results into its next decision. This is what gives it reach beyond text.
- Memory. Short-term memory holds the current task’s context; long-term memory (often a vector database) lets it recall facts and past interactions across sessions.
- The loop. The agent cycles through reason → act → observe → reason until done. The most common formulation is the ReAct loop (Reason + Act), which interleaves a Thought, an Action, and an Observation at each step so the agent can self-correct.
How a run actually unfolds
Given a goal, the LLM produces a thought and decides on an action — say, “search for the current exchange rate.” Your code executes that tool call and returns the result as an observation. The LLM reads the observation, reasons again, and chooses the next action. This continues until the model decides the goal is met and emits a final answer. Because the model chooses each action dynamically, an agent can handle tasks whose exact steps you could not script in advance — but the same flexibility is why it can also wander off course.
Examples and where it works today
Real implementations range from framework-level tooling to consumer products: OpenAI’s Assistants and function calling and Anthropic’s tool use give agents structured tool access; LangChain and LlamaIndex provide agent abstractions and memory; AutoGPT and CrewAI popularised multi-step and multi-agent autonomy.
Agents are reliable today for narrow, well-scoped jobs: support ticket triage, structured data extraction, code generation inside an editor, and research summarisation. They remain fragile for broad open-ended autonomy, because errors compound across steps and the model can take confident wrong actions. The practical pattern is to constrain the available tools, require human approval before anything risky or irreversible, cap the number of steps and the budget, and log every run so you can see exactly what the agent decided and why.