Telling an Agent From a Chatbot

You've probably used a chatbot. You type a question, it responds, and the conversation is over. An AI agent works in a completely different way. It doesn't just answer questions; it takes actions to accomplish goals.

Think of it this way: a chatbot is like a librarian who answers your questions. An AI agent is like a research assistant who goes out, finds information, synthesises it, makes decisions, and delivers a finished report.

One warning about the word itself before we go further. Agent was a job title long before it was a piece of software - a support agent, a travel agent, a real estate agent - and support teams still use it that way every day. So when someone at work says "the agent handled it", find out which kind they mean. Where this course could be misread, it says support rep for the person and keeps agent for the software.

How AI Agents Work

• Perception: They observe their environment (data, user requests, system states)
• Reasoning: They plan what to do next based on what they observe
• Action: They use tools and APIs - the connections that let one piece of software ask another for something - to get things done in the real world

Not every AI assistant works the same way. It helps to picture three points on a spectrum of autonomy - how much the system does on its own before it needs you.

• Chatbot: answers your question, then waits. The thinking and the next step are yours.
• Copilot: suggests options inside your workflow, but you approve every move.
• Agent: takes a goal and pursues it across multiple steps, choosing tools and recovering from errors along the way.

The table below shows how these three differ on the dimensions that matter when you're deciding what to deploy.

Many teams already run traditional automation: scripts, RPA bots (robotic process automation - software that clicks through screens the way a person would), and rule-based workflows. If that software already "does things automatically," what makes an agent different? It comes down to how each one handles the unexpected.

Toggle between the two below to see where each approach is strong, and where it struggles. The scores on each row are illustrative rather than measured - they mark the direction and rough size of the difference, not a benchmark result.

Autonomy is not free. Every decision or action you hand to an agent without a human checking in along the way is a moment where a mistake can happen unnoticed - and unlike a single bad response, that mistake can compound through several more steps before anyone catches it. This is why the chatbot-copilot-agent spectrum you just learned is not only a spectrum of capability. It is a spectrum of risk.

Two Very Different Worst Cases

Picture the worst thing that can go wrong with a chatbot: it gives you a wrong or unhelpful answer. You read it, notice something is off, and either correct it yourself or ask again. The damage is contained to that one exchange.

Now picture the worst thing that can go wrong with an agent. It is not one bad answer - it is a chain of actions, each one taken on the reasoning built up in the step before it. An AI support agent that misreads a policy does not just say the wrong thing; it might issue a refund that should never have gone out. An ordering agent that misjudges a match does not just suggest the wrong item; it might place a purchase. Some of these actions are reversible with effort. Some are not. The further an agent gets through a multi-step task before anyone looks at what it did, the more expensive - and sometimes irreversible - a bad decision becomes.

A Framework for Thinking About This Systematically

You do not need to design a full risk program to start building agents responsibly, but it helps to know one exists. The NIST AI Risk Management Framework (NIST AI 100-1) is the standard reference many organisations use to reason about AI risk in a structured way - broadly, mapping the risks a system could create, measuring how likely and severe they are, managing them through design and controls, and governing the process that keeps all of that current. This lesson will not teach you that framework in depth; Chapter 5 does that. The point here is simpler: as soon as you are talking about autonomy, you are already talking about risk, and there is a rigorous way to think about it waiting for you later in the course.

Back to Automation

Recall the earlier comparison between agents and traditional automation: automation is deterministic, so when it fails, it fails the same predictable way every time, and you can test for that failure in advance. An agent's autonomy is exactly what breaks that predictability. Because it reasons its way to a decision rather than following a fixed script, the same input will not always produce the same output - which means its risk surface is harder to map out ahead of time, and more important to monitor once it is live.