The global AI agents market was worth $7.84 billion in 2025. By 2030, MarketsandMarkets projects it reaches $52.62 billion, a 46.3% compound annual growth rate. These aren't fringe forecasts. They reflect the pace at which organizations are actually deploying agent systems: 67% of Fortune 500 companies had production agentic AI deployments in 2025, up from 19% just one year earlier, according to MightyBot.
The terminology problem is real, though. Ask five sources to name the types of AI agents and you'll get five different answers. IBM lists six. Wrike lists twenty-two. Databricks lists five. ChatGPT itself mixes two completely separate frameworks without noting that they diverge. That confusion has an explanation: the field actually has two parallel taxonomies, and most sources treat them as one.
The first is the classical taxonomy, five agent types formalized by Stuart Russell and Peter Norvig in Artificial Intelligence: A Modern Approach (first published 1995, now in its fourth edition). These are still the standard reference in CS curricula worldwide. The second is the modern taxonomy, five functional types that emerged with large language models starting around 2022, used by practitioners building agentic AI systems today.
Neither framework is complete without the other. Classical types explain the architectural logic underneath every agent system. Modern types describe what's actually running in production. This guide covers all ten types across both frameworks, maps how each classical type evolved into its modern equivalent, and offers a practical decision framework for choosing between them.
TL;DR: AI agent types span two taxonomies: 5 classical (Russell and Norvig, 1995) and 5 modern LLM-based (2022-present). The global market grows from $7.84B in 2025 to $52.62B by 2030 per MarketsandMarkets. 79% of companies have adopted agents per Capgemini Research. This guide covers all 10 types with comparison tables, a bridge framework connecting the two eras, and a practical selection guide.
What defines an AI agent and how does it bridge classical and modern approaches?
An AI agent is a software system that perceives its environment, reasons about it, and takes autonomous actions to achieve a goal. The term covers two related but distinct taxonomies: the five classical agent types defined by Russell and Norvig (1995), and the modern LLM-based agent types that emerged with the GPT era (2022-present). Both remain in active use. Classical types appear in textbooks and enterprise automation frameworks; modern types power commercial agentic AI products.
Russell and Norvig's original formulation puts it precisely: "An agent is anything that can be perceived as perceiving its environment through sensors and acting upon that environment through actuators. A rational agent is one that acts so as to achieve the best expected outcome." What separates an agent from ordinary software is the feedback loop: perceive, decide, act, observe the result, repeat.
Practitioners use the PEAS framework to characterize any agent: Performance Measure (how success is evaluated), Environment (where the agent operates), Actuators (how it acts), and Sensors (how it perceives). A spam filter has a simple PEAS profile. A coding agent that scaffolds a repository, runs tests, and commits fixes has a complex one. The environment properties, fully observable or partially observable, static or dynamic, deterministic or stochastic, largely determine which agent type is appropriate.
One distinction worth making before going further: AI agents are not the same as AI assistants. An AI assistant responds to a single request and stops. An AI agent pursues a multi-step goal autonomously. It plans, uses tools, observes results, and adjusts. As Harrison Chase, CEO of LangChain, put it: "A true agent has a goal, access to tools, the ability to take actions in the world, and a feedback loop that lets it learn from those actions."
According to Capgemini Research, 79% of companies have adopted AI agents as of 2025, with two-thirds reporting measurable value. A PwC AI Business Survey from the same year found 62% of organizations are at least experimenting with agents. The practical question has shifted from whether to use AI agents to which type fits which problem.
What are the 5 classical AI agent types that form the academic foundation?
The five classical agent types have been the standard academic taxonomy since Russell and Norvig's textbook first appeared. According to a PwC AI Business Survey in 2025, 62% of organizations are actively experimenting with AI agents, and many are unknowingly implementing these classical architectures in their automation stacks. Understanding them is the foundation for understanding everything built on top.
| Agent Type | Core Mechanism | Memory | Planning | Modern Equivalent |
|---|---|---|---|---|
| Simple reflex | Condition-action rules | None | None | Rule-based automation bots |
| Model-based reflex | Internal world state | Short-term state | None | Stateful conversational agents |
| Goal-based | Search and planning algorithms | State + goal representation | Yes | ReAct-pattern tool-use agents |
| Utility-based | Utility function optimization | State + utility model | Yes (with trade-offs) | Recommendation and optimization agents |
| Learning | Feedback-driven adaptation | Learned parameters | Emergent | LLMs (foundation of all modern types) |
Simple reflex agents
Simple reflex agents operate on condition-action rules: if X, then do Y. They have no memory, no awareness of history, and no ability to plan. They work only in fully observable environments where all relevant information is visible at the moment of decision. These agents are fast, cheap, and predictable. They also fail immediately when the environment becomes partially observable.
A thermostat is a simple reflex agent. So is a traditional spam filter that flags messages containing specific keywords. In the modern stack, workflow automation tools like Zapier or Make, when used without LLM integration, implement simple reflex logic: trigger A fires action B. Workflow automation agents in the AgentsIndex directory covers the practical options across this automation spectrum.
Model-based reflex agents
Model-based reflex agents extend the simple reflex design by maintaining an internal model of the world, a state representation that tracks aspects of the environment not currently visible through sensors. This lets them handle partially observable environments. The model updates as new information arrives.
The classic example is a robot vacuum that maps the rooms it has already cleaned. A modern equivalent is a stateful chatbot that remembers prior messages in a conversation session. These agents react to the current state rather than planning toward a goal, but they're no longer flying blind when conditions change. AI customer service agents that track conversation history across multiple turns are model-based agents in practice.
Goal-based agents
Goal-based agents add explicit objectives to the model-based design. They use search and planning algorithms to find action sequences that lead to a goal state. They can evaluate multiple possible futures before committing to an action. GPS navigation is the standard example: receive a destination, evaluate routes, select the optimal path, and update the plan in real time when conditions change.
This architecture maps almost directly to modern ReAct-pattern tool-use agents that reason about which action to take next, take it, observe the result, and plan the next step. The goal-based type is where classical AI theory and modern LLM-agent practice overlap most clearly.
Utility-based agents
Utility-based agents go beyond binary goal satisfaction to optimize a utility function, a numeric score that captures how good an outcome is. They can make trade-offs. A flight booking agent might optimize across price, travel time, and convenience, rather than simply finding any available flight. They handle uncertainty by maximizing expected utility.
Modern equivalents include recommendation systems (Netflix, Spotify), algorithmic trading agents, and autonomous vehicle path planners. Any agent making decisions involving competing priorities, speed vs. safety, cost vs. quality, is using utility-based reasoning, even if not labeled that way. Finance agents and data analysis agents in the AgentsIndex directory mostly implement utility-based logic at their core.
Learning agents
Learning agents improve performance over time through experience. Russell and Norvig's framework gives them four components: a learning element (updates the agent based on feedback), a performance element (selects actions), a critic (evaluates performance against a standard), and a problem generator (suggests exploratory actions to build knowledge).
This is the most consequential agent type. Modern large language models are learning agents at their foundation, trained via reinforcement learning from human feedback (RLHF), the critic-and-learning-element loop applied at massive scale. Every modern agentic AI product, from Claude to ChatGPT to Gemini, is built on a learning agent substrate. That makes this classical type the DNA of the entire modern taxonomy.
How do the 5 classical AI agent types work in practice?
https://www.youtube.com/watch?v=fXizBc03D7E
What are the 5 modern LLM-based AI agent types?
AI agent startup funding reached $3.8 billion in 2024, nearly tripling year-over-year investment according to CB Insights. The practitioners building with that capital don't use the classical taxonomy to describe what they're shipping. They use a second parallel framework organized around how modern LLM-powered agents actually work. These five types describe what's running in production today.
| Agent Type | Core Technology | Key Capability | Primary Examples | Segment CAGR (2025-2030) |
|---|---|---|---|---|
| Tool-use agents | LLM + function calling (ReAct loop) | Use external APIs, search, code executors | Claude with web search, ChatGPT Code Interpreter | ~46% |
| RAG agents | LLM + vector database retrieval | Ground responses in real-time or proprietary data | Notion AI, Confluence AI, legal research agents | ~46% |
| Multi-agent systems | Orchestrator + specialist sub-agents | Parallel specialized task decomposition | CrewAI, AutoGen, LangGraph | 48.5% (MarketsandMarkets) |
| Autonomous agents | LLM + persistent memory + long-horizon planning | Multi-day tasks with minimal human input | OpenAI Operator, Anthropic Computer Use, Manus AI | ~46% |
| Vertical/specialized agents | Domain-tuned LLM + domain-specific tools | Deep expertise in one industry or function | Harvey AI (legal), AlphaSense (finance), Eightfold AI (HR) | 62.7% (MarketsandMarkets) |
Tool-use agents
Tool-use agents are LLMs augmented with external tools via function-calling APIs. They operate in ReAct (Reason-Act) loops: reason about which tool to use, call the tool, observe the result, reason about the next step, and repeat. Tools include web search, code executors, calculators, databases, and third-party APIs. This is the most common modern agent architecture, and the one most readers have already encountered without naming it.
Claude with web search, ChatGPT with its Code Interpreter, and Google Gemini with Google Workspace integration are all tool-use agents. They extend the LLM's capabilities beyond training data cutoffs and into the real world. Without additional architecture, they can't pursue goals over long time horizons, that requires autonomous agent design. But for single-session multi-step tasks, tool-use agents are the standard starting point.
RAG agents
RAG agents (Retrieval-Augmented Generation) combine an LLM with a vector database to ground responses in real-time or proprietary data. Instead of relying solely on training data, the agent retrieves relevant documents at inference time, injects them into the prompt context, and generates a grounded response. As Jerry Liu, CEO of LlamaIndex, put it: "RAG agents are not just a retrieval trick, they're a fundamentally different trust model for AI. Instead of asking 'what does the model know?' you ask 'what can the model find and reason about?'"
RAG architecture matters most in compliance-sensitive industries where hallucinations have real consequences: legal, medical, financial. Iterative RAG agents retrieve, reflect on what they found, re-query if results are insufficient, and synthesize a grounded answer. Enterprise knowledge assistants like Notion AI and Confluence AI use RAG to let organizations query their internal documentation directly.
Multi-agent systems
Multi-agent systems are networks of specialized agents collaborating toward shared goals, typically with an orchestrator agent that decomposes tasks and delegates to specialist sub-agents. According to MarketsandMarkets, multi-agent systems are projected to grow at 48.5% CAGR from 2025 to 2030, driven by demand for complex task automation that exceeds what single agents can handle.
The practical advantage is parallelism and specialization. A software development multi-agent system might have a planner agent, a coding agent, a testing agent, and a deployment agent, each optimized for its role, working simultaneously on different parts of the problem. AI agent frameworks like CrewAI, AutoGen, and LangGraph make this architecture accessible. Teams evaluating which framework to build with will find the CrewAI vs LangGraph comparison a useful starting point.
Autonomous agents
Autonomous agents are goal-oriented systems that operate over long time horizons with minimal human intervention. They self-correct, self-plan, and adapt to unexpected states. What distinguishes them from tool-use agents is autonomy level: they can complete multi-step tasks spanning hours or days, maintaining persistent memory across sessions. As Dario Amodei, CEO of Anthropic, framed it: "Agentic AI represents the third wave: first we had rule-based AI, then we had generative AI, and now we have agentic AI, systems that can perceive, reason, plan, and act across complex workflows with minimal human oversight."
Examples include browser agents (OpenAI Operator, Perplexity Comet), computer-use agents (Anthropic Computer Use), and autonomous research agents (Gemini Deep Research, OpenAI Deep Research). MightyBot reports that 17% of Fortune 500 companies have full company-wide autonomous agent deployments as of early 2026. Browser agents are an emerging subcategory worth tracking specifically.
Vertical and specialized agents
Vertical agents are domain-tuned agents optimized for specific industries or functions. MarketsandMarkets projects this segment will grow at the highest CAGR of any agent category: 62.7% from 2025 to 2030. The reason is straightforward. General-purpose agents struggle where domain expertise matters most, in legal analysis, medical diagnosis, financial modeling, and HR screening. Harvey AI handles legal research and contract review. AlphaSense provides financial intelligence. Eightfold AI and Phenom operate in HR and recruiting. Legal agents, finance agents, and HR and recruiting agents in the AgentsIndex directory cover these specialized categories.
Why are coding agents becoming the fastest-growing agent category?
Coding agents deserve their own section. The coding and software development segment is projected to grow at 52.4% CAGR from 2025 to 2030 according to MarketsandMarkets, making it the second-fastest growing AI agent category. The commercial numbers are hard to argue with: Cursor reached $1.2 billion in annualized revenue in 2025 with 1,100% year-over-year growth, per MightyBot. Claude Code reached $1 billion in annualized revenue within six months of launch. Devin, developed by Cognition AI, reached a $10.2 billion valuation.
A coding agent is a specialized AI agent that generates, debugs, tests, and deploys code autonomously. They operate within IDEs (Cursor, Cline, Windsurf) or as standalone command-line agents (Claude Code, Devin, OpenHands). The most capable coding agents can scaffold entire repositories from a specification, fix bugs described in plain English, write and run tests, and commit working code. What makes coding an ideal domain for agents is the clarity of feedback: a test suite either passes or it doesn't.
How do coding agents fit the classical taxonomy? They're most directly descended from the learning agent type, using LLMs trained via RLHF on enormous code corpora, combined with goal-based planning (turn this issue description into passing tests) and tool use (read file, write file, run terminal command, observe output). GitHub Copilot focuses on autocomplete within an IDE context. Devin and Claude Code pursue multi-file, multi-step coding goals with minimal intervention. For teams choosing between specific coding agent tools, the comparison of the best AI coding agents covers the major options in depth. The Cline vs Cursor comparison is also worth reading for teams deciding between IDE-integrated tools specifically.
The speed of this segment's growth reflects something real. Coding is the agentic AI domain where productivity gains are most directly measurable and where the feedback loop for agent improvement is tightest. That combination of measurability and rapid iteration is why coding agents have reached billion-dollar revenue faster than any other agent category.
How do classical AI agent types correspond to modern LLM agents?
Here is what no competitor article explains: the classical taxonomy and the modern taxonomy are not separate things. They're the same architectural logic, 30 years apart. Every modern LLM-based agent type has a classical ancestor. Understanding this bridge is the key to understanding why different sources give different counts for agent types, and why both taxonomies remain useful.
| Classical Type | Core Logic | Modern Equivalent | Example Tools | Inherited Trait |
|---|---|---|---|---|
| Simple reflex agent | If X, do Y. No memory. | Rule-based automation bots | Zapier (trigger-action), Make workflows | Speed and predictability |
| Model-based reflex agent | Track world state, react to it | Stateful conversational agents | Customer service bots with session memory | Context awareness |
| Goal-based agent | Plan toward explicit goal | Tool-use agents (ReAct pattern) | Claude with tools, ChatGPT Code Interpreter | Multi-step planning |
| Utility-based agent | Optimize numeric utility function | Optimization and recommendation agents | Recommendation engines, trading algorithms | Trade-off reasoning |
| Learning agent | Improve via feedback loop | LLMs (foundation of all modern types) | GPT-4, Claude, Gemini via RLHF training | Adaptability and generalization |
The mapping reveals something worth pausing on: learning agents are not one modern agent type, they're the substrate for all of them. When you use Claude Code, you're using a learning agent (Claude, trained via RLHF) implementing goal-based logic (plan the coding task), tool-use patterns (read files, run tests), and operating in a multi-agent system if orchestrated through a framework like LangGraph. The taxonomies stack. They don't replace each other.
This also explains why different sources give different counts. IBM counts six because they add multi-agent systems to the classical five. Wrike counts twenty-two by listing functional application categories (sales agents, HR agents, research agents). DigitalOcean counts seven by adding hierarchical agents. None of these are wrong. They're answering slightly different questions about the same underlying taxonomy space. The classical framework asks "how does the agent reason?" The modern framework asks "what does the agent do?" Both questions are worth answering.
The naming problem compounds this. IBM calls them "simple reflex agents" while some practitioners call them "reactive agents." What IBM calls a "learning agent," practitioners call an "RLHF-trained model." What practitioners call a "tool-use agent" or "ReAct agent," academics would classify as a goal-based agent with a specific planning mechanism. Same systems, different vocabularies depending on which community you're in. Neither vocabulary is wrong; knowing both makes you useful in both rooms.
Which AI agent type should you choose for your specific use case?
North America held 40.1% of the global AI agents market revenue in 2025, per MarketsandMarkets, and the organizations spending that money are not asking "which type is best?" They're asking "which type fits this specific problem?" The agentic spectrum runs from fully deterministic (simple reflex) to fully autonomous (agentic AI). The right position on that spectrum depends on your use case's risk tolerance, data access, and task complexity.
| Use Case | Recommended Agent Type | Why | Human Oversight Level |
|---|---|---|---|
| Simple workflow automation (if-then triggers) | Simple reflex agent | Fast, predictable, cheap. No LLM needed. | Low (set and forget) |
| Customer support with session context | Model-based / stateful conversational | Tracks conversation history, handles follow-ups | Medium (escalation paths needed) |
| Research assistant with internal data | RAG agent | Grounds answers in your proprietary knowledge base | Medium (review outputs) |
| Complex multi-step workflows | Multi-agent system | Parallelism, specialization, error isolation | Medium-high (monitor pipeline) |
| Software development tasks | Coding agent | Generates, tests, and commits code autonomously | Medium (review PRs) |
| Long-horizon autonomous tasks | Autonomous agent | Handles multi-day goals with minimal interruption | Low-medium (goal-level oversight) |
| Domain-specific professional work | Vertical/specialized agent | Domain expertise built in with domain-specific tools | High for regulated domains |
A useful mental model: the more observable and deterministic your environment, the further left you can go on the classical spectrum (simpler, cheaper, more predictable). The more your task involves ambiguity, private data, or multi-step reasoning, the further into modern LLM-based types you need to go.
Human-in-the-loop requirements matter significantly. A financial compliance task where errors have legal consequences probably needs a model-based or RAG architecture with mandatory human review steps. A software test-writing pipeline that generates boilerplate tests can likely run with full autonomy. The question isn't "how smart can the agent be?" It's "how much can I trust the agent to operate without a human checking every step?"
One thing worth saying plainly: there is no universal best agent type. The best AI agent frameworks, CrewAI, LangGraph, AutoGen, PydanticAI, each have different strengths for different orchestration patterns. Multi-agent platforms in the AgentsIndex directory covers the practical options. For teams that need to compare specific frameworks before committing, the best AI agent frameworks guide is a natural next step from this taxonomy overview.
Frequently asked questions about AI agent types
What are the 5 types of AI agents?
The 5 classical AI agent types from Russell and Norvig are: (1) Simple reflex agents, which operate on condition-action rules with no memory; (2) Model-based reflex agents, which maintain an internal world state; (3) Goal-based agents, which use planning algorithms to reach explicit goals; (4) Utility-based agents, which optimize a numeric utility function to make trade-offs; and (5) Learning agents, which improve performance through experience and feedback. These five form the academic taxonomy first codified in Artificial Intelligence: A Modern Approach and still taught in AI courses worldwide.
What are the 7 types of AI agents?
The 7 types extend the classical 5 with two additional architectural patterns: (6) Hierarchical agents, organized in command hierarchies where orchestrator agents decompose tasks and delegate to specialist sub-agents; and (7) Multi-agent systems, networks of collaborative or competing agents working toward shared or competing goals. Some sources also distinguish reactive agents from deliberative agents as a seventh category, producing slightly different counts depending on the classification framework being applied.
Who are the Big 4 AI agents?
The "Big 4 AI agents" typically refers to the four dominant commercial AI platforms with agentic capabilities: ChatGPT (OpenAI), Claude (Anthropic), Gemini (Google), and Microsoft Copilot (powered by GPT-4). This is a brand classification, distinct from the technical taxonomy of agent types, which classifies agents by architecture rather than commercial platform. Each of these "Big 4" platforms uses multiple agent types simultaneously depending on the task at hand.
What is the difference between AI agents and AI assistants?
AI assistants respond to single requests and stop, they're reactive, not agentic. AI agents pursue multi-step goals autonomously: they plan sequences of actions, use tools, observe results, and adjust course without step-by-step human direction. An AI assistant answers "What's the weather in Paris?" An agent books your flight to Paris, monitors price changes, checks your calendar for conflicts, and reschedules if your preferred flight gets cancelled, completing the full goal with minimal human input along the way.
What is a learning agent in AI?
A learning agent is an AI system with four components: a learning element (updates behavior based on feedback), a performance element (selects actions), a critic (evaluates outcomes against a performance standard), and a problem generator (explores new actions to gather knowledge). Modern LLMs like GPT-4 and Claude are learning agents at their core, trained via reinforcement learning from human feedback (RLHF), which implements the critic-and-learning-element loop at scale. This makes the learning agent type the foundation for all modern agentic AI systems.
What are the next steps in understanding AI agents?
The AI agents landscape is moving fast. Startup funding tripled in 2024 to $3.8 billion per CB Insights, total private AI company funding reached $225.8 billion in 2025 per MightyBot, and the market grows from $7.84 billion to $52.62 billion by 2030 per MarketsandMarkets. New agent types and subcategories will emerge. But the foundational logic, perceive, reason, act, observe, stays consistent across all of them.
The practical takeaway from this guide: when choosing an AI agent type, answer two questions. First, how much autonomy does your use case require? That maps to the classical spectrum from reflex to learning. Second, what functional architecture fits your data and workflow? That maps to the modern taxonomy of tool-use, RAG, multi-agent, autonomous, and vertical types. Use both frameworks together. Don't let terminology differences between communities slow you down.
From here, the AgentsIndex directory organizes agents by category, making it easier to find specific tools without wading through hype. If you're evaluating frameworks for building multi-agent systems, the guide to the best AI agent frameworks is the natural next step. If software development is your primary use case, the guide to the best AI coding
Top comments (0)