An AI agent is a model that can act, not just answer. It calls a tool, reads what comes back, decides what happens next, and does it again — on its own, in a loop — instead of stopping at a paragraph of text and leaving every next step to a person.
The loop is the whole definition
A model becomes an agent the moment it can do three things in sequence, repeatedly: take an action, observe the result, and decide what to do next based on that result — then act again. Call, observe, decide, repeat, until the goal is met or the model runs out of road.
Each word is doing real work. "Call" means the model reaches outside its own text generation — querying a database, submitting a form, sending a request to some other system. "Observe" means the result of that call comes back into the conversation as information the model can use, not into a void. "Decide" means the next action is chosen based on what just happened, not fixed in advance by whoever wrote the prompt. Drop any one of the three and the loop collapses into something else: a script that always does the same thing regardless of what it finds, a single lookup with no follow-through, or a chatbot that only describes what taking action would involve.
A chatbot answers. An agent acts.
Ask a chatbot to find a hotel under $200 with free cancellation, and it answers with an approach to searching, or a handful of names it recalls, hedged with a suggestion to check prices yourself before booking. The text is the entire deliverable. Opening a browser, comparing listings, actually booking — all of that is still your job.
Ask an agent the same question and, if it has been given a search tool and a way to book, it queries listings, reads the results, filters for the cancellation policy, and comes back having either completed the booking or hit a decision that needs your input. The difference isn't that one system is smarter. It's that one of them can only produce language, and the other can produce consequences.
That also makes "agent" a capability claim rather than a personality claim. The reasoning underneath can be the identical model in both cases. What changes is whether it has been handed tools to call and the standing permission to call them.
What "acting" covers
In practice, the actions available to an agent tend to fall into a handful of buckets:
- Reading — querying a database, searching files, fetching a page.
- Writing — drafting a document, editing code, filling in a form.
- Calling other systems — hitting an API, triggering a webhook, invoking another program.
- Chaining steps — using the result of one call to decide the next, several times over, without a person re-prompting in between.
Those tools are usually exposed to the model through a defined interface — MCP, the most common one, describes a standard shape for it, so the model can discover what's callable and what each call expects, roughly the way a person reads a menu before ordering. What is MCP? covers that standard in plain English, if you want the deeper version.
Capability cuts both ways
An agent that can only read is roughly as safe as a chatbot — it can mislead, but it cannot cause anything outside the conversation. An agent that can also write, send, or delete takes on a second question along with that extra reach: what happens when it's wrong, or when something it reads is trying to steer it into acting against the person it's supposed to serve?
That question deserves its own answer, not a paragraph tacked onto a definition — a structural checklist for agents that can act covers assuming compromise, splitting proposal from execution, and capping what a single bad call can do. The one line worth carrying from here: the more an agent can do, the more that question matters, and "the model behaves well" is not an answer. Architecture is.
Agent isn't the only word in play
"Agent" gets used loosely alongside "assistant" and "bot," sometimes for the same product, sometimes for genuinely different things. If you're trying to place a specific system rather than pin down the base definition, assistant vs. agent vs. bot draws the actual distinguishing lines — who it acts on behalf of, whether it holds a standing relationship with a user, and whether it's conversational at all.
The fact worth keeping from this page: an agent is defined by what it can do, not by how it talks. A chatty system that only ever produces text is not an agent, no matter how convincingly it discusses acting. A quiet one that calls a tool, reads a result, and calls another is — even if it never addresses a person directly.
To see that loop running with a human check built into the handoff, connect an assistant.