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).
How Apple broke "Sign in with Apple" with an unannounced and silent redirect
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.
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.
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 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 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 evaluate sequences of actions to achieve specific objectives. Rather than just reacting to the current moment, they plan ahead.
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 adapt and improve through feedback loops. They get better at their tasks over time without explicit reprogramming.
Hierarchical agents decompose complex tasks into tiered sub-tasks. Higher-level agents delegate work to specialized subordinates.
Multi-agent systems involve multiple agents that collaborate or compete to solve problems too complex for any single agent working alone.
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.
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.
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.
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.
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.
Learning agents improve their behavior over time through experience. They consist of four components working together:
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.
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.
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.
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.
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.
Selecting an agent architecture depends on task requirements, environment characteristics, and operational constraints. The following framework walks through the key decision points.
Start by characterizing the environment where the agent will operate:
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.
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.
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.
Tasks requiring decomposition into specialized sub-tasks benefit from hierarchical architectures. Problems that involve parallel processing or distributed expertise point toward multi-agent systems.
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.
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).
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.
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.
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.
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.
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.
