Types of AI Agents: How to Understand and Choose the Right One
Seven types of AI agents, how each one makes decisions, and a practical framework for picking the right architecture for your use case (plus the identity controls each one needs).
AI agents are autonomous software systems that perceive their environment, reason about what they observe, and take independent action to achieve goals. Unlike traditional automation that follows fixed scripts, agents make decisions based on changing conditions. The type of agent you choose determines what kinds of decisions it can make, what data it needs to track, and how complicated your identity and authorization story has to be once you put it in production.
This guide walks through the seven major agent types, how each one works, and a practical framework for selecting the right architecture for your use case. We'll also cover the identity considerations for agentic AI that show up the moment any of these agents start taking real actions on real systems.
Key Takeaways
- Seven major agent types exist on a spectrum from simple condition-action rules to fully autonomous learning and multi-agent systems.
- The right agent type depends on environment observability, the complexity of goals, the rate of change, and whether the agent needs to learn from experience.
- LLM-based agents like GPT and Claude don't map cleanly to one classical type. They can exhibit characteristics of goal-based, learning, and hierarchical agents simultaneously.
- Every agent type requires identity. Simple reflex agents need machine credentials. Multi-agent systems need full delegation tracking. The taxonomy is also an identity-surface taxonomy.
- Picking the right architecture early prevents the rewrites teams hit when they realize their "simple agent" actually needed a planning loop, a memory layer, or another five agents to back it up.
What Is an AI Agent?
An AI agent is an autonomous software system that perceives its environment, reasons about what it observes, and takes actions to achieve specific goals. Unlike traditional programs that execute the same steps every time, an agent makes decisions on its own based on changing conditions.
Every AI agent has three core components. First, there's perception, which is how the agent gathers information about its surroundings. Second, there's decision-making logic, the reasoning process that determines what to do next. Third, there's action, how the agent actually affects its environment based on those decisions.
So what separates an AI agent from a simple automation script? The key difference is goal-directed behavior. For example, a thermostat turns on heat when temperature drops below a threshold. That's automation. An agent managing building climate considers occupancy patterns, energy costs, weather forecasts, and comfort preferences all at once. The agent optimizes across competing objectives rather than following a single rule.
The Main Types of AI Agents
AI agents fall into categories based on their complexity, intelligence level, and how they make decisions. The taxonomy starts with simple rule-followers and extends to sophisticated systems that learn and collaborate.
| Agent Type | Key Characteristic | Memory/State | Example Use Case |
|---|---|---|---|
| Simple reflex | Condition-action rules | None | Thermostat |
| Model-based reflex | Internal world model | Yes | Self-driving car |
| Goal-based | Plans toward objectives | Yes | Autonomous drone |
| Utility-based | Optimizes competing goals | Yes | Trading algorithm |
| Learning | Improves from feedback | Yes | Recommendation engine |
| Hierarchical | Delegates to sub-agents | Yes | Robotic assembly |
| Multi-agent | Collaborative systems | Distributed | Software dev teams |
Simple Reflex Agents
Simple reflex agents operate on straightforward condition-action rules with no memory of past events. If the sensor detects X, perform action Y. Nothing more complicated than that.
Model-Based Reflex Agents
Model-based reflex agents maintain an internal model to track aspects of the environment they cannot directly observe. A self-driving car tracks vehicles in its blind spots even when sensors can't see them.
Goal-Based Agents
Goal-based agents evaluate sequences of actions to achieve specific objectives. Rather than just reacting to the current moment, they plan ahead.
Utility-Based Agents
Utility-based agents use utility functions to optimize outcomes when multiple goals conflict. They choose the best trade-off rather than settling for any satisfactory solution.
Learning Agents
Learning agents adapt and improve through feedback loops. They get better at their tasks over time without explicit reprogramming.
Hierarchical Agents
Hierarchical agents decompose complex tasks into tiered sub-tasks. Higher-level agents delegate work to specialized subordinates.
Multi-Agent Systems
Multi-agent systems involve multiple agents that collaborate or compete to solve problems too complex for any single agent working alone.
How Simple Reflex Agents Work
Simple reflex agents map what they perceive directly to actions through condition-action rules. If the room is dark, turn on the light. If the inbox contains unread messages, display a notification. There's no history involved and no planning, just immediate response to current input.
- How it works: Direct mapping from current percept to action.
- Limitation: Fails when decisions require historical context.
- Best for: Fully observable, deterministic environments.
The simplicity here is both a strength and a weakness. Simple reflex agents are fast and predictable, but they cannot handle situations where the right action depends on what happened before. A spam filter using only simple reflex rules would evaluate each email in isolation without learning from previous classifications.
How Model-Based Reflex Agents Work
Model-based reflex agents maintain an internal representation of the world that gets updated with each new observation. That internal state lets them reason about things they cannot currently see.
Consider a self-driving car approaching an intersection. Even when another vehicle disappears behind a building, the car's internal model tracks its likely position. The agent combines what it perceives now with what it remembers from moments ago to make better decisions.
- How it works: Updates internal model based on percepts and previous state.
- Advantage over simple reflex: Handles partially observable environments.
- Best for: Dynamic environments where past context matters.
How Goal-Based Agents Work
Goal-based agents add explicit goal information to their world model. Rather than just reacting to stimuli, they consider which action sequence will get them to their objective.
This approach requires search and planning capabilities. The agent explores possible futures and evaluates which paths lead toward the goal. An autonomous drone routing through a city doesn't just avoid the obstacle directly in front of it. The drone plans a complete path to its destination, accounting for buildings, no-fly zones, and battery constraints.
- How it works: Combines world model with goal information to select actions.
- Key capability: Reasons about future states.
- Best for: Tasks with clear success criteria and multiple paths to completion.
How Utility-Based Agents Work
What happens when an agent has multiple goals that conflict? A utility-based agent assigns numerical preference values to different outcomes and selects actions that maximize expected utility.
A stock trading algorithm might balance profit maximization against risk minimization. There's no single "goal" to achieve in the traditional sense. The agent continuously optimizes across competing objectives, finding the best available trade-off given current market conditions.
- How it works: Assigns preference values to states, selects actions maximizing utility.
- Advantage over goal-based: Handles trade-offs between conflicting objectives.
- Best for: Optimization problems with competing priorities.
How Learning Agents Work
Learning agents improve their behavior over time through experience. They consist of four components working together:
- Learning element: Modifies the agent based on feedback from past actions.
- Performance element: Selects actions based on current knowledge.
- Critic: Evaluates how well the agent is doing against a standard.
- Problem generator: Suggests exploratory actions that might yield new learning.
Recommendation engines exemplify this pattern well. They start with basic assumptions about user preferences, observe actual user behavior, and continuously refine their predictions. The agent that recommended movies to you last year has meaningfully different internal weights than the one serving you today.
How Hierarchical Agents Work
Complex tasks often decompose naturally into sub-tasks. Hierarchical agents mirror this structure, with high-level agents delegating to specialized subordinates.
In a robotic assembly line, a top-level agent handles production scheduling while delegating welding, painting, and quality inspection to specialized sub-agents. Each level focuses on its domain of expertise. Coordination flows through the hierarchy, with parent agents breaking down objectives and child agents reporting results.
- How it works: Breaks complex tasks into manageable sub-tasks across tiers.
- Coordination: Higher-level agents orchestrate lower-level execution.
- Best for: Complex workflows requiring specialized sub-processes.
How Multi-Agent Systems Work
Some problems exceed what any single agent can handle effectively. Multi-agent systems distribute work across multiple autonomous entities that communicate, collaborate, and sometimes compete with each other.
- Communication: Agents share information and coordinate actions through defined protocols.
- Collaboration vs. competition: Agents can work together toward shared goals or act in self-interest.
- Emergent behavior: System-level outcomes arise from individual agent interactions.
Modern AI coding assistants often use multi-agent architectures. One agent writes code, another reviews it, and a third runs tests. The system's overall capability emerges from their interaction rather than from any single agent's abilities. For an applied example of multi-agent identity at work, see enabling the agentic economy with Ory and Skyfire.
How LLM-Based Agentic AI Maps to the Agent Taxonomy
Large language models like GPT and Claude become agents when combined with tool use, memory, and autonomous action capabilities. The base model alone isn't an agent. LLM-based agentic systems now represent a major and rapidly growing category.
LLM-based agents can exhibit characteristics of multiple agent types simultaneously. They reason in natural language rather than hardcoded logic. They interact with APIs, databases, and external systems through tool use. They can be configured as goal-based, learning, or hierarchical depending on how developers implement them.
The key distinction from traditional agents is general-purpose reasoning versus task-specific programming. A traditional goal-based agent has its planning logic explicitly coded. An LLM-based agent derives planning capabilities from its language understanding, which makes it more flexible but also less predictable. For the deeper picture on how this maps to identity, see our guide on AI agents vs agentic AI, agentic AI security with MCP and OAuth, and the honest take on what makes agentic AI good vs bad.
How to Choose the Right AI Agent Type
Selecting an agent architecture depends on task requirements, environment characteristics, and operational constraints. The following framework walks through the key decision points.
1. Define the Task and Environment
Start by characterizing the environment where the agent will operate:
- Observability: Can the agent see everything relevant, or is some information hidden?
- Dynamics: Does the environment change while the agent operates?
- Determinism: Do the same actions always produce the same results?
2. Assess Observability and State Requirements
If the environment is fully observable and deterministic, simple reflex agents may suffice. Partial observability, where the agent cannot see everything it would like to know, requires model-based approaches that track hidden state over time.
3. Determine Goal Complexity and Trade-Offs
A single clear objective points toward goal-based agents. Multiple competing objectives, where you're optimizing rather than just satisfying a condition, call for utility-based approaches that can weigh trade-offs explicitly.
4. Decide if the Agent Will Learn
When optimal behavior is known in advance and the environment is stable, learning adds unnecessary complexity. When the environment is novel, changing, or too complex to specify rules for, learning capabilities become essential.
5. Plan for Coordination and Scale
Tasks requiring decomposition into specialized sub-tasks benefit from hierarchical architectures. Problems that involve parallel processing or distributed expertise point toward multi-agent systems.
Identity and Access Considerations for AI Agents
As agents become autonomous, they require identity management like any other system actor. Machine identities in enterprise environments have grown substantially in recent years, and that growth accelerates dramatically with agentic AI deployments where agents spawn dynamically and operate across system boundaries.
Authenticating Autonomous Agents
Each agent operating in your infrastructure requires a verifiable identity. The challenge intensifies when agents create other agents or when a single logical agent operates across multiple services. Standards like OAuth 2.0 and OpenID Connect provide foundations for machine authentication, though machine-scale authentication with high volumes of short-lived agents requires purpose-built infrastructure (the MCP server authentication with Ory Hydra guide shows the integration end-to-end, and identity security risks for autonomous agents covers the readiness gap).
Authorizing Agent Actions With Least Privilege
Agents benefit from accessing only what they require for their specific task. Fine-grained, granular permissions prevent scenarios where a compromised or misbehaving agent causes cascading damage across systems. The principle of least privilege, long established for human users, becomes even more critical when agents operate at machine speed without human review of each action. For the AI-specific picture, see access controls for AI and LLM systems.
Auditing and Traceability at Machine Scale
Every agent action ideally traces back to its identity. At high volumes, this creates significant infrastructure demands. Audit trails remain essential for compliance and incident response. When something goes wrong, you want to know which agent did what, when, and under whose authority.
Building Secure AI Agents With Ory
Ory's identity for agentic AI platform addresses agent identity at machine scale through open source components including Ory Hydra, Ory Kratos, and Ory Keto. The architecture supports high-volume, low-latency agent registrations and authentications while maintaining granular authorization controls. For teams deploying agentic AI systems, Ory provides the identity infrastructure to authenticate agents, enforce least-privilege permissions, and maintain audit trails across distributed agent deployments. The future of identity for agentic AI covers where this approach is heading.
Frequently Asked Questions About Types of AI Agents
Are Large Language Models Like GPT and Claude Considered AI Agents?
LLMs become AI agents when combined with tool use, memory, and autonomous action capabilities. The base model alone is not an agent because it only generates text in response to prompts. LLM-based agentic systems that take actions, use tools, and pursue goals independently do qualify as agents.
How Do AI Agents Differ From Bots and RPA Scripts?
AI agents reason and adapt to achieve goals, while bots and RPA scripts follow predetermined sequences without autonomous decision-making. A bot executes the same steps every time. An agent evaluates its situation and chooses actions based on its objectives and current conditions.
The agent taxonomy isn't just a vocabulary exercise. Picking the right architecture early saves you from the kind of rewrites that turn into multi-quarter engineering projects. The identity surface is part of that decision too. A simple reflex agent and a multi-agent system require very different identity infrastructure, and both fail in expensive ways when you don't think about that until production. For CISO-level reading on what readiness looks like, see the Agentic AI Identity Security Readiness whitepaper. For the wider picture, the customer identity and access management hub covers it end to end.
Further reading

Stop managing parallel identity stacks. Discover how Ory enforces agent security directly inside the runtime event loop using your existing identity infrastructure.

AI agent integration connects agents to data and actions. Compare custom, iPaaS, MCP, and unified-API approaches, and the identity controls that keep them safe.

Before blocking AI agent actions, turn the lights on. Learn why visibility, monitoring, and understanding normal agent behavior are crucial before enforcing policy

Agentic AI governance controls what autonomous agents can do. Learn the key risks, a five-pillar framework, and how to implement runtime controls.

