In this guide
Agent vs Chatbot
A chatbot answers you. An agent takes a goal and keeps working on its own until the task is finished. Modern versions of both run on the same kind of model. What changes is how many steps happen before a human sees anything.
What a chatbot is
A chatbot is built around a conversation. You send a message, it sends one back, and then it waits. That back-and-forth, one turn each, is the entire shape of it.
The word covers two fairly different things. Older chatbots — the kind still sitting behind a lot of support widgets — match what you typed against a list of predefined intents, meaning a set of request types someone wrote out in advance, and reply with a scripted answer. They're cheap and predictable, and they fall over the moment someone asks something nobody scripted. Newer ones put a language model behind that same conversational shape, so the replies aren't written ahead of time and unexpected phrasing stops being fatal.
What both versions share is where control sits. The chatbot produces its reply, then stops. Whatever happens next is your call.
An agent keeps going without you
An agent starts from a goal instead of a message. Give it one and it works in a loop: pick an action — usually calling a tool, meaning a specific outside action it can trigger, like running a search or reading a file — then look at what came back and pick again, repeating until it judges the task done. You aren't in that loop. A chatbot hands control back after every single reply; an agent keeps going for as many steps as the task needs, and you see the outcome at the end.
The AI agent page covers that loop in full.
Agent vs chatbot, side by side
| Chatbot | Agent | |
|---|---|---|
| What you give it | A message | A goal |
| What you get back | A reply | A finished task, or an attempt at one |
| Who decides what happens next | You do, every turn | The model, until it stops |
| Steps before you see anything | One | As many as the task takes |
| Tool use | Sometimes, to look something up before replying | Central — act, check the result, act again |
| Cost per request | One call, or two if it looks something up | Several, sometimes many |
| What a failure looks like | A bad answer, in front of you | An action already taken, that you didn't watch |
A common claim worth correcting: you'll often read that agents "learn and improve from every interaction" while chatbots can't. That isn't how either one works. A model's weights — the numbers fixed during training that determine how it responds — don't change while you use it. What gets described as learning is memory: the system storing past messages, notes, or retrieved documents and feeding them back in as context next time. Genuinely useful, but it's storage, not learning.
Is ChatGPT a chatbot or an agent?
Both, depending on how you're using it. Type a question into ChatGPT and read the reply — that's a chatbot. But ChatGPT, Claude, and Gemini all also offer modes that take a goal and work through it over many steps, browsing and running code before coming back with a result. Used that way, the same product is an agent.
The names for those modes change constantly, and OpenAI has already retired or renamed several of its own. So the label is a poor guide. What makes something an agent isn't the model, the brand, or the name on the mode — a chatbot can call a tool to answer you and still be a chatbot. It's whether several steps run without you in between. "Agentic" is a spectrum rather than a category, which the agentic AI page covers directly.
Which one should you build?
Build a chatbot when the person should stay in control of each step. Answering questions, explaining a policy, helping someone find the right document — the value is in the reply itself, and the human decides what to do with it. It's cheaper (one or two model calls per turn instead of many), it responds faster, and it's far easier to keep safe, because it isn't touching your systems.
Build an agent when finishing the work is the point and the steps can't be listed in advance. If a task takes an unknown number of lookups, checks, and corrections, stopping to show a human every intermediate step gives back the time you were trying to save.
Two real cases. An internal benefits-questions bot should be a chatbot: employees need an answer they can act on themselves, and something that started changing enrollment records on its own is a liability, not a feature. Triaging a failing nightly build should be an agent: nobody can say ahead of time which logs matter, and the value is in reaching a diagnosis, not in narrating each step along the way.
One caution. "Agent" has become a marketing word, and plenty of products sold as agents are a chat interface with a single tool bolted on. The test isn't what it's called. It's whether the system takes several steps of its own accord before a human sees anything.
If you land on "agent," there's a second question waiting behind it: whether those steps genuinely can't be scripted in advance. Agent vs workflow covers that one.