Quick answer: What is an AI agent? An AI agent is a software system that uses a large language model as its reasoning engine to autonomously perceive its environment, plan a sequence of actions, execute those actions using tools, and pursue a goal — iterating until the goal is complete, without requiring a human to direct every step. Unlike a chatbot, which responds to one message at a time, an agent decides what to do next based on what it observes, takes real actions in the world (browsing, coding, sending messages, calling APIs), and adapts when results are unexpected. |
You have probably noticed that "AI agent" is appearing everywhere — in product announcements, developer tools, and boardroom discussions. But the term is used loosely enough that it has started to mean very different things to different people. A customer service chatbot is sometimes called an agent. So is a fully autonomous coding system that writes, tests, and deploys software without human involvement.
The difference matters enormously — for what you can build, for what can go wrong, and for how you should govern and oversee these systems.
This is Part 1 of a four-part series on AI agents. Here we establish the foundation: what an agent actually is, how it differs from a chatbot and from traditional automation, and where the technology came from. Parts 2, 3, and 4 cover architecture and design patterns, real-world applications, and safety and failure modes respectively.
The Definition — Precise, Layered, and Useful
The one-sentence definition
An AI agent is a software system that uses a large language model as its cognitive core to autonomously perceive its environment, plan a course of action, execute that plan using tools, and pursue a stated goal — iterating through observe-decide-act cycles until the goal is achieved or human intervention is needed.
Every word in that definition carries weight:
Autonomously: the agent decides what to do next based on what it observes — not because a human explicitly told it to do that specific thing at that moment. The human specifies the goal; the agent determines the path.
Perceive: the agent reads real inputs from its environment: web pages, files, API responses, tool outputs, error messages. Without perception there is no feedback loop, and without a feedback loop there is no adaptation.
Plan: the agent reasons about what to do next, given the goal, the current state, and what has already been tried. This is the job of the LLM — reading accumulated context and determining the best next action.
Execute using tools: the agent doesn't just describe actions — it takes them. Searching the web, writing and running code, calling an API, writing a file, sending a message. Real effects in the world.
Iterating: a single action followed by a single observation is not agency. Agency is a loop: observe → decide → act → observe again. Repeated until the task is done.
The intuitive framing: from consultant to employee
The cleanest way to understand AI agents is by contrast with what came before.
A chatbot is like the most knowledgeable consultant you have ever met. You ask a question; they give a brilliant answer. You ask another; they answer again. Each exchange is discrete. They never pick up the phone on your behalf, never open your laptop, never take any action in the world.
An AI agent is more like a capable new employee. You give them a goal and the tools to pursue it. They figure out the steps, execute them, handle routine obstacles, and come back to you when they hit something genuinely beyond their scope.
The shift in a single sentence: a chatbot tells you what to do. An agent does it.
This distinction has profound implications for productivity, for what can go wrong, and for how organisations need to govern and oversee these systems. Most of this series is concerned with those implications.
The three properties every agent must have
Not every LLM-powered system is an agent. Three properties must all be present:
Perception: the system reads inputs from its environment beyond what the user typed — tool outputs, web page contents, file contents, API responses, error messages. This creates the feedback loop that distinguishes an agent from a one-shot system.
Reasoning and planning: the system decides what to do next based on what it observed and the goal it is pursuing. The LLM provides this — reading the accumulated context and determining the best next action.
Action: the system takes consequential actions — not just describes them. Running code, calling an API, writing a file, sending a message, clicking a button. Pure text generation is not action.
Iteration — the loop connecting all three — is what makes them meaningful. A system that perceives once, reasons once, and acts once without checking whether the action worked is not an agent. It is a sophisticated one-shot pipeline.
Agents vs. Chatbots vs. Automation — The Critical Distinctions
"Agent," "chatbot," and "automation" are used interchangeably in a lot of coverage. They are not the same thing, and the differences matter for what you build, deploy, and trust.
AI agent | Chatbot | Traditional automation | |
Reasoning engine | LLM — flexible, general | LLM or rule-based | Rule-based, scripted |
Handles novel situations? | Yes — adapts via reasoning | Partially — within trained scope | No — breaks outside defined paths |
Takes real-world actions? | Yes — via tools | No — text responses only | Yes — but only scripted actions |
Runs a loop? | Yes — multi-step iteration | No — single turn or short exchange | No — linear execution |
Adapts when plans fail? | Yes | No | No |
Reliability | Moderate and task-dependent | High within narrow scope | Very high within defined scope |
Best for | Open-ended, multi-step goals | Q&A, conversation, simple tasks | Repetitive, well-defined processes |
Agents vs. chatbots
Chatbots and agents both use large language models, and both can hold a conversation. The difference is what happens after the conversation.
A chatbot responds. It takes your message, generates a response, and waits for your next message. It does not take any action in the world. It does not check whether its advice was correct. It does not loop back and try something different if the first attempt did not work.
An agent acts. It takes your goal, determines what steps are needed, executes each step using tools, observes the result, and decides what to do next — without waiting for you to direct each move.
Concrete example: you ask both "find me the cheapest flight from Mumbai to Singapore next Friday." The chatbot tells you to check Google Flights or Skyscanner and gives you some tips on when to book. The agent opens a flight search tool, runs the query with your stated constraints, compares results, selects the best option, and returns a confirmed recommendation with a link — ready to book.
Agents vs. traditional automation
This comparison is less intuitive but equally important. Robotic Process Automation (RPA) and scripted workflows have been around for decades. They automate repetitive digital tasks by following predefined sequences of steps. So how is an AI agent different?
Traditional automation is rigid but reliable. An RPA workflow that logs into a system, extracts data from specific fields, and writes it to a spreadsheet will do exactly that — every time, without variation, as long as the system interface does not change. The moment the vendor updates the form layout, the script breaks. The moment an unexpected dialog box appears, the script hangs. RPA is extraordinarily reliable within its defined scope and completely brittle outside it.
AI agents are flexible but less predictable. An agent encountering an unexpected dialog box reads it, reasons about what it means, and decides how to respond — possibly correctly, possibly incorrectly, but without breaking entirely. An agent given a task that requires a slightly different approach than usual can adapt. The trade-off is reliability for flexibility.
Neither is universally superior. For high-volume, well-defined, stable processes — payroll processing, invoice extraction, data migration — traditional automation is the right tool. For tasks that require judgment, adaptation, or handling of novel situations — research, complex document processing, multi-system coordination with variable inputs — agents provide capabilities that scripted automation simply cannot.
The right tool for the right job Use traditional automation when the process is: stable and well-defined, inputs are predictable, reliability matters more than flexibility, and errors are expensive. Use AI agents when the task requires: judgment on ambiguous inputs, adaptation when situations vary, coordination across multiple systems or information sources, or handling of situations that cannot all be anticipated upfront. |
A Brief History — From Rule-Based Agents to LLM-Powered Ones
Classical AI agents (1950s–1990s)
"AI agent" is not a new concept. It has been foundational to the field since the beginning. Russell and Norvig's "Artificial Intelligence: A Modern Approach" — the standard university textbook since 1995 — opens with the definition of a rational agent: a system that acts to maximise its expected utility given what it perceives. That framing has never changed. What has changed, dramatically, is the quality of the reasoning engine inside.
Early agent systems were landmark achievements in their time. STRIPS (1971) was the first AI planning system, representing world states as logical propositions and searching for sequences of actions that would transition from the current state to the goal state. These systems worked within their defined domains and failed completely outside them. The brittleness was not an engineering flaw — it was a fundamental limit of symbolic AI. You cannot hand-code knowledge about every situation a general-purpose agent might encounter.
Reinforcement learning agents (1990s–2010s)
Reinforcement learning offered an alternative: instead of hand-coding knowledge, train an agent to learn a policy — a mapping from observed states to actions — by rewarding good outcomes and penalising bad ones. No explicit knowledge engineering required.
The results within bounded, well-defined domains were spectacular. DeepMind's DQN played Atari games from raw pixels at superhuman level. AlphaGo defeated the world Go champion. AlphaStar reached Grandmaster level in StarCraft II. These were genuinely remarkable achievements — and they all shared a critical limitation: the trained policy was specific to the environment it was trained in. Generalising to a new task, a new domain, or a novel situation required retraining from scratch.
The LLM turn: language as a universal planning interface (2022–present)
The insight that changed everything: a large language model trained on a trillion tokens of human knowledge and reasoning is itself a general-purpose reasoning engine. If you can describe a task in natural language — and almost any task can be — the model can reason about it without domain-specific training.
The ReAct paper (Yao et al., Princeton and Google, 2022) demonstrated this empirically. By interleaving explicit reasoning steps with action steps (calling web search, database, and calculation tools), agents dramatically outperformed both pure reasoning (no tools) and pure action (no explicit reasoning) on multi-step information tasks. "ReAct" — Reasoning + Acting — became the name of the dominant agent pattern in use today.
Toolformer (Meta AI, 2023) showed that LLMs could learn when and how to call external tools from examples alone — inserting API calls into their own reasoning wherever useful. AutoGPT (March 2023) packaged these ideas into a consumer-accessible agent with internet and file system access, briefly becoming the fastest-growing GitHub repository in history. The results were inconsistent. The interest was overwhelming. AI agents had crossed from research into public awareness.
Why LLMs broke the generalisation barrier Classical agents were brittle because their knowledge was finite and manually specified. RL agents were brittle because their policy was learned in one specific environment. LLMs absorbed the breadth of human knowledge and reasoning across trillions of tokens — encountering descriptions of, and reasoning about, an enormous range of situations. An LLM-based agent meeting a novel situation doesn't break; it reasons from analogous cases absorbed during training. It may reason incorrectly — but it reasons, rather than failing silently. |
Summary and What's Next
AI agents are not a new category of chatbot — they are a new category of software. Software that pursues goals, adapts to obstacles, executes actions through tools, and operates across time horizons that single LLM responses cannot address.
The three key distinctions to carry forward: agents act where chatbots respond; agents adapt where traditional automation breaks; and agents combine the flexibility of language understanding with the ability to take real-world actions.
Part 2 of this series goes inside the agent: the LLM brain, the tools, the memory systems, the planning mechanisms, and the major architectural design patterns — ReAct, plan-and-execute, multi-agent, and human-in-the-loop.