Types of AI agents
From a thermostat's reflex to a fleet of LLMs planning together — the same word, very different minds.
The classic AI taxonomy ranks agents by how much of the world they model: simple reflex, model-based reflex, goal-based, utility-based, and learning agents. Modern LLM agents remix these ideas — ReAct tool-users, planners, and multi-agent systems — but they still map cleanly onto the same ladder of increasing internal state and foresight.
Simple reflex agent
The simplest agent maps the current perception straight to an action through fixed condition-action rules, with no memory of the past. It works only when the right choice depends entirely on what it senses right now, like a thermostat reacting to temperature. Change the environment slightly and it has no way to notice or adapt.
Model-based reflex agent
This agent keeps an internal model of how the world works and a running estimate of its current state, so it can act sensibly even when it can't observe everything at once. The model fills the gaps left by partial perception, letting it track things that are temporarily out of view. It still reacts rule-by-rule, but now reacts to a remembered picture rather than a single snapshot.
Goal-based agent
A goal-based agent is given a target and searches for a sequence of actions that reaches it, using planning rather than reflex. It can reason about the future — asking 'if I do this, will it bring me closer to the goal?' — which lets it handle situations no rule anticipated. This is where deliberate, multi-step behavior first appears.
Utility-based agent
When several goals compete or several paths reach one goal, an agent needs a way to say which outcome is better. A utility-based agent scores states with a utility function and chooses actions that maximize expected utility, trading off speed, cost, risk and reward. It answers not just 'can I reach the goal?' but 'what is the best way to?'
Learning agent
A learning agent improves its own behavior over time from feedback instead of relying on hand-written rules or a fixed model. A performance element acts while a learning element critiques the results and updates the policy, so the agent gets better with experience. This is the bridge from classical AI to modern machine-learning-driven agents.
LLM tool-users & planners
Modern LLM agents recast these ideas. A ReAct agent interleaves reasoning traces with tool calls — think, act, observe, repeat — behaving like a goal-based agent whose 'model' is a language model. Planning agents go further, decomposing a task into ordered sub-steps before executing, closer to explicit search over a plan.
Multi-agent systems
The frontier is not one agent but many: specialized LLM agents (a researcher, a coder, a critic) coordinated by an orchestrator, passing messages and results between them. Dividing labor lets each agent stay focused and lets the system tackle problems too big for a single context window. Coordination, roles, and communication protocols become the new design problem.
What an 'agent' actually is
In AI, an agent is anything that perceives its environment through sensors and acts upon that environment through actuators in pursuit of some objective. That definition is deliberately broad — a thermostat, a chess program, a self-driving car, and a tool-wielding language model are all agents — which is exactly why the word causes so much confusion. The interesting question is never "is it an agent?" but "how sophisticated is the mind behind the actions?"
The classical taxonomy, from Russell and Norvig's standard AI text, answers that by ranking agents on a single axis: how much of the world the agent represents internally, and how far ahead it looks before acting. Each rung on the ladder keeps more state and reasons further into the future than the one below it. Understanding the ladder matters today because the "AI agents" everyone is building on top of large language models are not a break from this lineage — they are new implementations of the same old rungs, and naming which rung a system occupies is the fastest way to reason about what it can and cannot do.
The reflex agents — acting on the here and now
The bottom two rungs react rather than deliberate.
- A simple reflex agent chooses its action purely from the current perception using fixed condition-action rules:
if temperature > 22 then turn off heat. It holds no memory and builds no picture of the world, so it is fast, predictable, and utterly brittle — it only behaves well when the correct action depends entirely on what is visible right now. In a partially observable world it fails, because it literally cannot represent anything it isn't sensing at this instant. - A model-based reflex agent fixes that by maintaining internal state: a model of how the world evolves and how its own actions affect it, plus a running estimate of the current situation. That lets it handle partial observability — remembering the car in its blind spot, or that a door it passed was locked. It still acts by rules, but the rules now consult a remembered model of reality rather than a bare snapshot.
The jump from the first to the second is the first appearance of the idea that drives the whole hierarchy: keeping state lets an agent cope with a world it cannot see all at once.
Goal-based and utility-based — looking ahead
The next two rungs stop reacting and start deliberating.
A goal-based agent is handed an explicit goal and searches for a sequence of actions that achieves it. Instead of a rule for every situation, it reasons about the future: it can simulate "if I take this action, does the resulting state bring me closer to the goal?" This is where planning and search enter, and it is enormously more flexible — a goal-based navigator can route around a road closure it has never seen before, because it reasons from the goal rather than from a memorized rule.
A utility-based agent adds judgment on top of goals. Real problems rarely have a single binary goal; usually many outcomes are acceptable but some are better, or several goals conflict. A utility function assigns a number to each possible state — capturing speed, cost, risk, comfort — and the agent chooses actions that maximize expected utility. This lets it make rational trade-offs under uncertainty: not just "reach the destination" but "reach it fastest while staying safe and cheap." Utility is what turns a goal-seeker into an optimizer.
Learning agents and the modern LLM flavors
A learning agent is orthogonal to the others: any of the above can be made to improve itself. It splits into a performance element that decides actions, a critic that judges outcomes against a standard, a learning element that updates the agent from that feedback, and a problem generator that suggests exploratory actions. Rather than being fully specified by hand, it gets better with experience — the conceptual bridge to modern machine learning.
Large language models gave rise to a new family that sits on top of this ladder:
- ReAct tool-users interleave *reasoning* and *acting* — the model thinks a step, calls a tool (search, code, an API), observes the result, and loops. Functionally it is a goal-based agent whose world-model is the LLM itself.
- Planning agents go further by decomposing a task into an explicit ordered plan of sub-tasks before executing, closer to classical search over a plan, which makes long tasks more reliable.
- Multi-agent systems replace one agent with several specialized ones — a researcher, a coder, a critic — coordinated by an orchestrator that routes messages and merges results.
Each is a fresh implementation of an old rung: reflex, goal, utility, learning — now powered by a language model instead of hand-written rules.
Choosing the right rung
The practical value of the taxonomy is that it stops you from over- or under-building. Every rung up the ladder buys capability at the cost of complexity, latency, and unpredictability, so the engineering question is always "what is the simplest agent that solves this problem?"
If the correct action depends only on the current input, a reflex agent (or a single stateless LLM call) is cheaper, faster, and easier to debug than anything fancier. If the task needs memory of an unobservable world, you need state. If it needs multi-step reasoning toward an outcome, you need a goal-based or ReAct design. If outcomes must be traded off, you need utility. And only when a single agent's context or competence genuinely can't hold the whole problem should you reach for a multi-agent system — coordination overhead, message-passing bugs, and runaway loops are real costs that a well-scoped single agent avoids. The taxonomy, old as it is, remains the clearest map for deciding how much mind a job actually requires.
Simple reflex agents act only on the current perception via condition-action rules — no memory.
Model-based reflex agents keep internal state to handle a world they can't fully see at once.
Goal-based agents search and plan toward a target; utility-based agents pick the best among competing goals.
Learning agents improve their own behavior from feedback instead of staying fixed.
Modern LLM agents are new flavors: ReAct tool-users interleave reasoning and actions, planners decompose tasks, multi-agent systems coordinate specialists.
The ladder is about internal state and foresight — each rung models more of the world than the last.
Quick quiz
What distinguishes a model-based reflex agent from a simple reflex agent?
A ReAct-style LLM agent most closely resembles which classical type?
How AI agents chain tools, memory & reasoning
An LLM in a loop that plans, acts, observes — and keeps going until it's done.
MCP vs API vs A2A protocol
Three connectors for three different conversations — apps, models, and agents.
How large language models work
The machine that learned to talk by predicting the next word, a trillion times over.
RAG vs Agentic RAG
Classic RAG looks things up once. Agentic RAG hires a researcher who keeps digging until the answer holds up.