Types of AI Agents: The Classic 5, Plus How Modern Agents Fit
October 30, 2026
There are five classic types of AI agents: simple reflex, model-based reflex, goal-based, utility-based, and learning agents. Each one adds a capability the previous one lacks: memory, then a goal, then a way to rank outcomes, then the ability to improve. On top of those five, agents are also grouped by structure, as hierarchical agents and multi-agent systems.
Most guides stop there. The more useful question in 2026 is where today's agents fit: a language model calling tools in a loop, a coding agent editing a repo, or a computer-use agent clicking through a browser.
Here's the short version:
| Type | Decides using | Everyday example |
|---|---|---|
| Simple reflex | The current input only | A thermostat switching the heat on below a set temperature |
| Model-based reflex | Current input + remembered state | An inventory system that counts orders already in transit |
| Goal-based | State + a target to reach | A route planner finding a path to your destination |
| Utility-based | State + a score for how good each outcome is | A route planner trading off time, tolls, and traffic |
| Learning | Any of the above + feedback that improves it | A spam filter that gets better as you mark messages |
| Hierarchical | A manager agent delegating to sub-agents | A warehouse robot with separate motion and task layers |
| Multi-agent | Several agents interacting | A team of AI agents splitting a research task |
Below: what each type actually does, where each breaks, and how the classic categories map onto the AI agents you can use today.
The 5 classic types of AI agents
The standard taxonomy comes from Stuart Russell and Peter Norvig's textbook Artificial Intelligence: A Modern Approach, the book most university AI courses use. It defines an agent as anything that perceives its environment and acts on it, then sorts agents by how they choose what to do next.
The Wikipedia entry on intelligent agents uses the same order, where each type keeps what the previous one had and adds one thing.
Simple reflex agents
A simple reflex agent runs condition-action rules: if you see X, do Y. It looks only at the current input and has no memory of anything that happened before.
A thermostat, an email filter rule, and a keyword-triggered chatbot reply are all simple reflex agents. They're fast, cheap, and completely predictable. They also fail the moment the right action depends on something they can't currently see. A vacuum robot with only a "this square is dirty" sensor has no idea whether it already cleaned the rest of the room, so it can wander forever.
Model-based reflex agents
A model-based reflex agent adds internal state, a remembered picture of the world. It updates that picture using what it just saw and what it knows about how the world changes, then applies its rules to the picture instead of to the raw input.
That fixes the vacuum problem: the robot remembers which squares it has visited. It's still rule-driven, though. There's no goal and no planning, just better information feeding the same kind of rules.
This type deserves more than a paragraph, and it has one: our model-based reflex agent guide covers how the internal model works and why the state problem keeps resurfacing in modern systems.
Goal-based agents
A goal-based agent knows where it's trying to end up. Instead of matching a rule, it asks: which action gets me closer to the goal? That usually means search or planning, looking ahead at sequences of actions before committing to one. Automated planning is the branch of AI built around exactly this.
A route planner and a chess engine searching for checkmate are both goal-based. The gain is flexibility: change the goal and the same agent does something different, with no rule rewriting. The cost is computation, and the agent can only judge outcomes as "reaches the goal" or "doesn't."
Utility-based agents
A utility-based agent replaces the yes/no goal with a score. It rates how good each possible outcome is, then picks the action with the best expected score, factoring in how likely each outcome is.
This matters whenever there's more than one way to succeed. Two routes both reach the airport. One is faster but crosses a toll road, and the other is free but often jammed. A goal-based agent treats both as success. A utility-based agent weighs time, money, and risk and picks the better trade-off.
Navigation apps, recommendation rankers, and bidding systems all work this way. The hard part is designing the score. A utility function that leaves something out gets optimized anyway, and the agent will cheerfully sacrifice whatever you forgot to measure.
Learning agents
A learning agent improves from feedback. Russell and Norvig split it into four parts: a performance element that picks actions, a critic that judges how well things went, a learning element that changes behavior based on that judgment, and a problem generator that suggests new things to try.
A spam filter that improves as you mark messages is one; a game-playing system trained with reinforcement learning is another.
One detail most lists get wrong: learning isn't really a fifth rung on the ladder. It's a separate dimension. You can bolt a learning component onto a reflex agent or a utility-based agent alike. "Learning" describes how an agent gets better, not how it decides.
Types of agents by structure: hierarchical and multi-agent
The five types describe how a single agent decides. Two more categories describe how agents are arranged.
Hierarchical agents
A hierarchical agent splits work into layers. Lower layers handle fast, simple reactions. Higher layers handle slower, more deliberate decisions and hand instructions down.
A warehouse robot is a good picture of it: the bottom layer keeps it balanced and avoids collisions, a middle layer drives it to a shelf, and the top layer decides which orders to pick next. Rodney Brooks' subsumption architecture from the 1980s is the classic robotics version of this idea.
Multi-agent systems
A multi-agent system has several agents interacting in a shared environment. They might cooperate (robots splitting a floor to clean), compete (bidding agents in an auction), or both.
This is where the classic taxonomy and modern AI meet most directly.
How the classic types map onto modern LLM agents
Today's agents are mostly built on large language models. An LLM agent is a language model given tools and a loop, so it can act instead of only answering. The classic categories still apply. They just describe the system around the model more than the model itself.
| Modern agent | Closest classic type | What gives it away |
|---|---|---|
| Rule-based automations and keyword bots | Simple reflex | Fixed triggers, no memory |
| Tool-using LLM agents | Goal-based, with model-based state | Given an objective, chooses its own steps; context window acts as memory |
| Coding agents | Goal-based with a utility-style check | Passing tests is the score it works toward |
| Computer-use agents | Model-based + goal-based | Sees only screenshots, so it must track state it can't see |
| Multi-agent orchestration | Hierarchical / multi-agent | A lead agent delegates to specialist sub-agents |
| Agents with long-term memory | A weak form of learning | Behavior changes across sessions; model weights don't |
Tool-using agents
The basic modern agent is a model that can call tools, such as search, a calculator, a database query, or an API, and decides which to call and when. That makes it goal-based: you hand it an objective, it plans steps toward it.
The most common loop for this is ReAct, short for reason plus act, from a 2022 research paper: think about the next step, call a tool, read the result, repeat. Our ReAct agent explainer walks through that loop step by step.
The state problem from model-based agents never went away, either. The context window is the agent's internal model. When it fills up or gets summarized badly, the agent forgets what it already tried and repeats itself, the same failure the vacuum robot had.
Coding agents
A coding agent such as Claude Code reads a codebase, edits files, runs commands, and checks the results. Its goal is the task ("fix this bug"), but what makes it work is a measurable score: do the tests pass, does the build succeed, does the linter complain?
That's the utility-based idea in practice, and an automatic way to grade outcomes is why coding became the first area where agents got genuinely useful. With no test to run, the agent is back to judging its own work, which is far less reliable.
Computer-use agents
A computer-use agent controls software the way a person does: it takes a screenshot, decides where to click or what to type, acts, and takes another screenshot.
It's the clearest modern case of partial observability. Seeing one screen at a time, it must remember what was on the previous page and what it already filled in. That's model-based reasoning feeding a goal-based plan, and it's why these agents are still slower and more fragile than tool-calling agents that hit an API directly.
Multi-agent orchestration
When a task is too big for one context window, builders split it up. A lead agent breaks the job down and sends pieces to specialist sub-agents. That's a hierarchical design wearing new clothes.
Anthropic's guide to building effective agents names this pattern "orchestrator-workers." The OpenAI Agents SDK builds it in through handoffs, where one agent passes control to another. Most agentic AI frameworks offer some version of the same thing.
The classic trade-off still holds: more agents means more coordination overhead and more places for a misunderstanding to spread. A single well-equipped agent often beats a committee.
How to pick the right type of agent for a job
The taxonomy works best as a sizing tool: it tells you how much machinery a problem actually needs, which is usually less than you'd think.
Work down this list and stop at the first one that fits:
- Are the rules known and the input complete? Use a simple reflex setup. An automation rule or a script is cheaper and more predictable than any model.
- Are the rules known, but you need to remember things? Add state. A model-based reflex design with a database behind it will do.
- Do the steps change from case to case? Now you need a goal-based agent that plans, which is where an LLM agent earns its cost.
- Are there several acceptable outcomes with real trade-offs? Give the agent an explicit way to score them: tests, a rubric, or a checker agent that reviews the output.
- Is one agent's context too small for the job? Only then split it into multiple agents.
Anthropic's guide makes the same point from the builder's side. It separates workflows, where code fixes the steps, from agents, where the model directs its own process, and recommends starting with the simplest option that works.
It's also worth knowing what isn't an agent. A chat assistant that answers each message and waits for the next one doesn't pick its own steps. The difference between AI agents and AI assistants comes down to who decides what happens next.
Key points
- The five classic types of AI agents are simple reflex, model-based reflex, goal-based, utility-based, and learning
- Each adds one capability: memory, then a goal, then a way to score outcomes, then improvement from feedback
- Learning is a separate axis, not a fifth level, and hierarchical / multi-agent describe arrangement, not decision-making
- Most modern LLM agents are goal-based, with the context window standing in for the internal model
- Coding agents work because tests give them a score; computer-use agents struggle because they see one screen at a time
- Pick the simplest type that fits — multi-agent orchestration is often more than a task needs
Knowing the type is the easy part. Getting a working agent onto your own machine, with its tools and setup already wired, is where most people stall. Taku is an AI-native desktop workspace where you can mirror an agent setup someone else already got running, then remix it for your own work. Taku is in Beta, and the Mac app is available now.
FAQ
What are the 5 types of AI agents?
Simple reflex agents, model-based reflex agents, goal-based agents, utility-based agents, and learning agents. The list comes from Russell and Norvig's Artificial Intelligence: A Modern Approach, and it orders agents by how much information and reasoning they use to pick an action.
What are the different types of agents in AI besides the classic five?
Agents are also grouped by structure. Hierarchical agents split decisions into layers, with higher layers directing lower ones. Multi-agent systems have several agents cooperating or competing. Modern products add labels like tool-using agents, coding agents, and computer-use agents, which describe what the agent works on rather than how it decides.
What is the difference between goal-based and utility-based agents?
A goal-based agent only knows whether an outcome reaches the goal. A utility-based agent scores outcomes, so it can choose between two options that both succeed, like a fast toll route versus a slower free one.
What is a model-based agent?
Usually this means a model-based reflex agent, one that keeps an internal picture of the world so it can act when its current input doesn't show everything. It still follows rules; the memory just gives those rules better information.
What type of agent is ChatGPT or Claude?
On its own, a chat model answering one message at a time is closer to an assistant than an agent. Once it's given tools and a loop and handed an objective, as in Claude Code or other agent products, it behaves like a goal-based agent, with the conversation history acting as its internal state.
Do LLM agents learn while they work?
Mostly no. The model's weights are fixed during use. Some agents save notes or memories between sessions, which changes their behavior over time, but that's a much weaker form of learning than the classic learning agent, which updates its own decision-making from feedback.
Which type of AI agent should I use?
The simplest one that handles the job. Fixed rules with complete information need only a reflex setup. Tasks whose steps change each time need a goal-based agent. Reach for multiple agents only when one agent's context genuinely can't hold the task.