A chatbot answers. An agent acts — it plans, calls tools, observes what happened, and tries again until the job is done. That single difference is the reason "add an LLM" and "ship an AI system" are two completely different projects.
For two years the default AI experience was a text box: you ask, the model replies, and nothing in the world changes. Useful, but bounded. The model can't look anything up it wasn't trained on, can't touch your systems, and can't recover when its first answer is wrong. An agent closes that loop. Give a model a goal, a set of tools, and permission to run in a loop, and it stops being a conversationalist and becomes a worker.
The loop is the whole idea
Every agent, no matter how fancy, runs the same core cycle. Step through it below.
Why the loop changes everything
A chatbot gets exactly one shot. An agent gets as many as it needs — and, crucially, it can check its own work between attempts. On tasks that require looking something up, using a calculator, or touching a real system, that difference is enormous. Here is roughly what we see when the same underlying model is given the same multi-step tasks, first as a single-shot chatbot and then as a tool-using agent.
The catch: acting is riskier than talking
When a chatbot is wrong, you get a bad sentence. When an agent is wrong, it can send the wrong email, update the wrong record, or spend real money. Autonomy raises the stakes, which is why the interesting engineering in agentic systems isn't the model — it's everything around it:
- Tools with guardrails — every action an agent can take is a function you wrote, with its own permissions and limits.
- Evaluation in the loop — the agent scores its own output, and you score the agent, on every run.
- Human-in-the-loop — high-stakes actions pause for approval instead of firing blindly.
- Observability — every plan, tool call, and result is logged so you can see exactly what happened and why.
Key takeaways
- Agents differ from chatbots by running a loop: plan → act → observe → reflect.
- The loop lets them use tools and self-correct, which wins on multi-step, real-world tasks.
- Autonomy raises the stakes, so guardrails, evals, and observability are the real work.
Thinking about an agent?
We design agents that act on your systems safely — with the guardrails and evaluation to run them in production.