"Agent" has become one of the most overused words in AI - a chatbot with a system prompt gets called an agent, a single API call wrapped in a script gets called an agent, and a genuinely autonomous multi-step system also gets called an agent. They're not the same thing, and the difference isn't pedantic: it changes what you can rely on the system to do without you watching it.
The one-sentence definition
An AI agent is a system where a model decides what to do next, not just what to say next - it observes some state, chooses an action (often calling a tool), sees what happened, and decides again, repeating until the task is done. The defining trait is that the sequence of steps isn't fixed in advance by a human; the model determines it at run time based on what it's seeing.
What that rules out
A standard chatbot response - even a good one - isn't agentic on its own: the model receives a message and produces a message back, once, with no ability to act on anything in between. A hardcoded script that always calls the same three APIs in the same order isn't agentic either, even if an LLM writes the final summary at the end, because the sequence of steps was decided by whoever wrote the script, not by the model reacting to what it finds along the way.
A chatbot responds once. A script follows a fixed path. An agent decides its own next step, based on what it observes.
Three ingredients that usually show up together
In practice, "agentic" systems tend to combine three things: autonomy over the sequence of steps (the model decides what happens next, not a developer), tool use (the ability to take actions in the world - search, call an API, write a file - not just generate text), and a loop that continues until some stopping condition is met, rather than a single request-response exchange. None of these alone makes something an agent; it's the combination, and specifically the model being in the driver's seat for what happens next, that does.
Why the distinction actually matters
It's not just terminology. Autonomy is exactly what makes agents both more capable and riskier than the alternatives: a script can only do what its author explicitly wrote, which is limiting but predictable; an agent can handle situations nobody anticipated, which is powerful but means it can also take actions nobody anticipated. Every later guide in this series - tools, memory, evaluation - exists because that unpredictability has to be managed somehow, not eliminated (eliminating it would just turn the agent back into a script).
Where this fits with the rest of this site
If you've been through the LangGraph, LangChain, or n8n guides on this site, you've already built or seen agentic systems in practice - the "AI Agent node" in n8n and a LangGraph graph with a conditional loop are both concrete implementations of exactly the plan-act-observe pattern this series is about, just in different tools. This series stays framework-agnostic and focuses on the underlying concepts those tools are all implementing.