Definition
An AI agent is a software system that pursues a goal on its own by repeatedly deciding what to do next — reading its environment, choosing an action, taking it with a tool, checking the result, and repeating until the task is finished. In 2026 the term almost always means an LLM-powered agent: a large language model used as the decision-maker inside a loop, with access to tools, memory, and the ability to take real actions.
The distinction that matters is autonomy across steps. A chatbot answers the message in front of it and stops. An agent is given a goal — "fix this failing test," "process this refund," "research this market" — and decides for itself how many steps that takes and which tools to use. If a system waits for a human to specify every action, it is being used; if it chooses its own next action, it is an agent.
How It Works
An agent runs a loop. Give it a goal, and it cycles through four moves until the goal is met or it gives up and escalates:
- Perceive — read the current state: the user's request, a file, an API response, the output of its last action.
- Reason — the LLM decides the next step, often writing out its reasoning before choosing (the ReAct pattern: reason, then act).
- Act — call a tool: run code, query a database, search the web, send an email, edit a file. Tool calls are how an agent changes the world instead of just describing it.
- Observe — feed the tool's result back in and loop. A wrong result is not a dead end; the agent sees the error and tries again.
A concrete run makes this tangible. Ask a coding agent to fix one failing test and a single "task" expands into a dozen steps: it reads the traceback, greps for the function, opens three files, edits one, runs the test (still red), reads the new error, edits again, reruns (green). That is roughly ten tool calls and three act-observe iterations — none of which you specified. This step-count is also where the cost lives: because every step resends the whole accumulated transcript to the model, a 20-step run costs far more than 20 one-off prompts. Token usage grows with roughly the square of the number of steps, which is why a long-running agent can quietly become expensive and slow.
AI agent vs chatbot, LLM, RAG, and workflow
These get conflated constantly, and the difference is who decides the next step:
| System | What it does | Who picks the next step | Example |
|---|---|---|---|
| Bare LLM | Turns one prompt into one response | Nothing — single shot | A model answering a question via API |
| Chatbot | Multi-turn conversation, no real-world actions | The human, each turn | A support bot that only replies with text |
| RAG | Retrieves documents, then answers once | Fixed pipeline | Q&A over a company knowledge base |
| Agentic workflow | A designed sequence of LLM steps | The developer, in advance | A summarize-then-critique-then-rewrite pipeline |
| AI agent | Pursues a goal, tools in a loop | The model, at run time | A coding agent that fixes a bug end-to-end |
The line between an agentic workflow and an agent is control: a workflow follows a path the developer laid out, while an agent decides the path itself as it goes. When several agents split the work, that is a multi-agent system.
Types
The textbook taxonomy (from Russell & Norvig's AI: A Modern Approach) sorts agents by how much they reason before acting. It predates LLMs but still describes what an agent's control loop is doing:
- Simple reflex agents — act on the current input alone with condition-action rules ("if smoke, sound alarm"). No memory; blind to anything not in the present percept.
- Model-based reflex agents — keep an internal model of the world, so they can act on state they cannot currently see (a robot vacuum remembering which rooms it already cleaned).
- Goal-based agents — consider the future, choosing actions that move toward an explicit goal. This is where planning enters.
- Utility-based agents — weigh how good each outcome is, not just whether it meets the goal, optimizing a utility function when goals conflict or trade off.
- Learning agents — improve from feedback over time, often via Reinforcement Learning, rather than staying fixed.
Most 2026 LLM agents are goal-based agents with a learning component: the model plans toward a goal, and the system improves through fine-tuning and feedback. These categories are not exclusive — a real agent usually blends several. The orthogonal question of how many agents you run is covered under multi-agent systems.
Real-World Applications
Named, in-production examples as of 2026 — not hypotheticals:
- Coding agents — Claude Code and Cursor read a repository, run tests, edit files, and open pull requests. This is the most mature agent category, because code gives instant, checkable feedback (the tests pass or they don't).
- Customer support deflection — agents that read a ticket, look up the order in internal systems, and resolve or issue a refund, rather than routing to a human. The measurable target is deflection rate: tickets closed with no human touch.
- Deep research — agents that run dozens of web searches, read sources, cross-check claims, and produce a cited report in minutes instead of an analyst's afternoon.
- Computer-use / RPA replacement — agents that operate a browser or desktop by clicking and typing, automating legacy apps that expose no API.
The common thread: each task involves multiple steps against systems the model cannot solve in one shot, and each has a checkable outcome. Where there is no way for the agent to verify its own result, agents are far less reliable and rarely deployed unsupervised.
Key Concepts
An agent is only as capable as its tools: function calling is the mechanism by which an LLM requests an action, and the Model Context Protocol (MCP) is the emerging standard for connecting agents to tools and data without bespoke glue for each one. Planning — decomposing a goal into steps — is what turns those tools into a coherent sequence, and weak planning is the most common reason an agent wanders or loops. Because the context window alone cannot hold a long task, agents also need memory: working memory for the current task and often longer-term memory across sessions.
The concept that makes an agent safe to deploy is human-in-the-loop — a guardrail checkpoint where the agent pauses for approval before a costly or irreversible action, such as spending money, deleting data, or emailing a customer. Deciding which actions require sign-off, rather than letting the agent act freely, is often the difference between a demo and a production system.
Challenges
The failure modes below are specific to running an LLM in an autonomous loop, and they are why agents are harder to ship than a chatbot. The most fundamental is that errors compound. A chatbot that is reliable per turn is fine, but an agent multiplies its per-step reliability across every step: if each step were, say, 95% reliable and a task took 20 of them, it would finish correctly only about 36% of the time (0.95²⁰ — an illustration, not a measured rate). Reliability that reads as excellent for a single answer becomes a coin-flip across a long task, which is why step count is the enemy. Cost and latency scale with the loop for a related reason: resending the growing transcript each step makes tokens accumulate super-linearly, so a task that "should be quick" can run for minutes and cost dollars.
The other two challenges are about safety and measurement. Tool access is an attack surface: an agent that reads untrusted content — a web page, an email, a document — and can also take actions is exposed to prompt injection, where hidden instructions in that content hijack its goal, and the blast radius equals the permissions its tools were granted (an agent with delete access can be talked into deleting). And evaluation is hard, because there is rarely a single "correct" trajectory, so knowing whether an agent is improving means grading outcomes across many runs rather than checking one answer.
Future Trends
- Longer-horizon tasks — the practical frontier is task length: the number of steps an agent can chain before it drifts off course is rising, pushing agents from minutes-long tasks toward hours-long ones.
- Agent-to-agent communication — the Agent2Agent Protocol aims to let agents from different vendors delegate to one another, the way MCP standardized tool access. It is now the single such standard: IBM's Agent Communication Protocol merged into it in August 2025, so the contest that existed in 2025 has already resolved.
- Computer-use agents — operating any software through its screen, removing the "needs an API" limit on what can be automated.
- On-device agents — smaller models running locally for latency, privacy, and cost, handing off to a frontier model only for the hard steps.