The types of AI agents describe how a system chooses actions or changes through experience. One product can be goal-based, LLM-powered, and multi-agent at the same time, because those labels refer to different parts of its design. As teams put agents into production, these design choices shape how the software handles real requests.
In LangChain’s public survey of 1,340 professionals conducted in late 2025, 57.3% reported having AI agents in production. For a product team, putting an agent into use means deciding how it will choose actions and which changes it is allowed to make.
This guide explains how the five foundational designs work and where LLMs and multi-agent systems fit. You’ll learn how to match those designs to your product’s needs and assess claims that an agent learns from feedback.
What is an AI agent, and how does it work?
An artificial intelligence (AI) agent uses what it observes to choose what to do. For a software agent, those observations include messages and data from connected services.
The AI agent components connect these observations to a decision. The agent’s decision logic interprets the available evidence and selects a response, such as requesting more information or submitting an update.
An AI agent works through a cycle in which each response helps guide its next decision. After it requests an update, the connected service’s reply helps show whether the change took effect. The agent uses that evidence to decide whether to continue or try another way to complete the update.
A chat interface gives you a way to send requests to an agent, but the conversation alone does not reveal its decision logic. Permissions place a separate limit on what it is allowed to change and when human approval is required.
These decisions follow different designs. Some agents respond only to the current input, while others draw on past events or consider where an action would lead.
5 types of AI agents and how they work
The five foundational types of agents in AI are simple reflex, model-based reflex, goal-based, utility-based, and learning agents. IBM uses this five-type framework to explain its decision mechanisms.
These AI agent types overlap when an agent learns as well as following rules or planning. A system that plans toward a goal, for example, also acts as a learning agent if experience changes its behavior. The types describe what agents do, rather than stages every business has to pass through.
| Type | How it chooses an action | Main limitation |
| Simple reflex | Matches the current observation to a fixed rule | Misses relevant history |
| Model-based reflex | Selects a response from rules and its stored view of the environment | Depends on keeping that view accurate |
| Goal-based | Plans actions toward an objective | A goal alone does not rank successful alternatives |
| Utility-based | Scores alternatives against stated preferences | Incomplete preferences distort the choice |
| Learning | Uses experience to update future behavior | Updates require performance testing |
Simple reflex agents: Responding to current inputs

A simple reflex agent applies a rule to what it observes now. It does not refer to past events.
Consider a simplified heating controller programmed to send a heat-on command below 68°F and a heat-off command at or above it. A reading of 64°F always triggers heat-on, regardless of earlier temperatures or commands. This isolates a simple reflex rule rather than describing every real thermostat, which often includes other controls.
A simple reflex rule suits a decision based only on the current reading. Because the rule is explicit, you can trace the response to what triggered it. Tests assess whether the rules cover the cases the agent will face.
Missing history limits this design. If the same reading calls for different responses depending on an earlier event, a current-input rule lacks the context to choose correctly. Tracking earlier observations gives the agent context beyond the current reading.
Model-based reflex agents: Tracking internal state

A model-based reflex agent keeps an internal state, or a record of what it believes is true about its environment. It updates that state using new observations and a model of how conditions change. Rules then select a response based on that state.
Internal state supplies context when the agent cannot observe everything that matters. In a robot-navigation teaching example, the robot keeps a record of obstacles it has found. Their locations stay in that record even when its sensors no longer see them.
Accurate state tracking depends on new observations. If conditions change beyond the agent’s view, its record becomes stale. Until fresh observations arrive, its decisions depend on an incomplete view of the environment.
Goal-based agents: Planning toward an objective

A goal-based agent chooses actions by assessing whether they lead to a goal. It looks ahead to plan a sequence of actions toward that goal.
Route planning shows how this works. A destination sets the goal, while a map of available roads supports the search for a route. If a road becomes unavailable, the planner searches again with the updated conditions. Replanning changes the route without necessarily changing the planner’s underlying knowledge or decision rules.
A precise goal makes success easier to test. In route planning, a stated destination gives a direct question: did the route reach the required location? A vague goal such as “find a good route” leaves the planner and the person testing it with different ideas of what counts as success.
Reaching a goal does not tell the agent which successful option to prefer. Several routes reach the same place but differ in travel time or cost. A utility-based design adds a way to rank them.
Utility-based agents: Comparing outcomes and tradeoffs

A utility-based agent compares choices using a utility function, which scores how desirable an outcome is. When outcomes are uncertain, it weights each possible outcome’s score by its probability. Adding those weighted scores gives the expected utility of a choice.
This scoring helps when several options meet the same goal but differ in cost or service level. The function expresses how much those differences matter, giving the agent a basis for choosing among otherwise successful options.
The choice is only as sound as the preferences captured in the score. If the function leaves out an important consequence, an option that scores highly could still disappoint the business. The agent is optimizing the formula it was given, including any gaps in that formula.
Non-negotiable requirements belong outside this tradeoff calculation. These hard constraints are rules every eligible option must satisfy. Excluding options that break them prevents another benefit from outweighing a breach, which a scoring penalty alone would still allow.
Learning agents: Adapting through feedback

A learning agent uses experience to change what it knows or how it behaves. Learning therefore describes how an agent adapts, whether it follows rules or plans toward a goal. The classical learning-agent model explains this adaptation through four roles:
- Performance element: Chooses what the agent does using its current knowledge.
- Critic: Judges what happened against an external standard and supplies feedback.
- Learning element: Uses that feedback to change how the performance element chooses actions.
- Problem generator: Suggests actions that gather new information for learning.
These roles connect an agent’s past attempts to changes in its later decisions. A modern implementation does not have to put each role in a separate service, but it still needs a mechanism that turns feedback into an update.
An update is not proof of improvement. Later tests compare the new behavior with the intended goal, while human review provides an assessment beyond the agent’s own view of its answer. That evaluation helps establish whether the change addressed the original problem.
The same distinction applies to saved experience. A saved history shows what the agent retained, while later responses help establish whether it used that experience or improved its behavior.
AI agent memory vs. learning: What changes after feedback?
Agent memory stores facts or past events for later use. Learning changes what the agent knows or does through experience. A saved correction supports that change only if the agent retrieves it and applies it to a relevant case.
Updating a model’s instructions, or prompt, offers one way to adapt without retraining it. LangChain’s LangMem is a software development kit (SDK) for agent memory. Its prompt optimizer uses past interactions and feedback to propose revised instructions while the model’s trained parameters, called weights, stay unchanged.
Those revisions still require testing. A correction that helps one case might mislead another, and stored knowledge becomes stale when business rules change. Later tests assess whether the update fixed the error without breaking previously correct responses.
Measured memory gains also depend on the setup. The 2026 EvoMemBench study tested several rounds of software commands and responses in an in-episode execution benchmark. DeepSeek-V3.2’s reported success rate was 28.5% without memory and 43.0% with the ReasoningBank memory method. Both used a context budget of 16,000 tokens, or pieces of text processed by the model.
Assessing a learning claim therefore involves tracing the correction to a lasting change, such as revised instructions or stored knowledge. Later tests and AI agent monitoring help establish whether the changed behavior holds up in use.
Where LLM agents and multi-agent systems fit
An agent’s model, the way it cooperates, and its business role describe different parts of its design. One agent therefore carries several labels.
What makes an LLM part of an AI agent?
An LLM helps an agent interpret language and choose what to do, while app code carries out the permitted requests. The model receives the returned data and uses it to choose its next response. AI agent frameworks help implement this loop and keep track of its progress.
A database lookup shows the division of responsibility. The model requests the lookup, but app code checks permissions before running the query. The returned data then informs the model’s next decision.
Completing this loop does not, by itself, update the model’s trained weights. Learning requires a way to update what the agent knows or how it behaves.
How multi-agent and hierarchical systems organize agents
A multi-agent system contains agents that interact. A hierarchy adds a lead agent that divides a request among other agents and combines their findings.
This arrangement describes who coordinates the work, while the foundational types explain how each agent makes decisions. A lead agent that plans toward an objective is goal-based, even when it operates within a hierarchy. Neither the number of agents nor their reporting structure establishes whether they learn from experience.
The practical tradeoff is the extra coordination. Each agent’s findings have to reach the lead in a form it understands and uses. If that transfer fails, the lead loses evidence it was meant to combine, so the design depends on reliable handoffs as well as individual decisions.
Business roles do not define an AI agent’s architecture
Role-based labels describe the work an agent is assigned. They leave open whether it follows fixed rules or plans a sequence of actions, so a role alone does not establish how the agent makes decisions.
Permissions define a separate part of that assignment: the changes the agent is allowed to make and those that require approval. A complete description therefore covers both its decision logic and the authority granted to it.
How to choose the right AI agent type for your business
Choose an AI agent type by matching its decision-making to your product’s requirements. Your team also needs a way to test whether those decisions lead to the intended result.
For decisions governed by fixed rules, the key question is whether the current input supplies enough context. A simple reflex design uses that input alone, while a model-based design keeps track of relevant earlier events. When success requires a sequence of actions, planning links those actions to a goal. If several sequences reach the goal, a utility function adds a way to compare their tradeoffs.
Two questions connect those mechanisms to the feature you intend to build:
- How is the next action selected? Ask which observations influence the choice and what confirms completion. The answer identifies the role of rules or retained state, as well as any planning.
- What changes through experience? If the feature promises adaptation, identify what updates and how the team tests later performance. That explanation establishes what the learning claim covers.
Available data constrains these choices. A planner lacks a reliable basis for its decisions if the required records are missing. Access to those records also differs from permission to change them, so the design has to account for both.
Splitting a request across agents adds coordination work. That effort has to serve your product’s needs. Model calls and integrations affect AI agent development cost by adding usage costs and engineering work.
Choose AI agents around your business requirements
Choosing an AI agent type starts with the behavior your product needs. Some decisions follow clear rules, while others depend on retained context or planning.
Before commissioning a build, assess those choices with your development partner using a real request. A walkthrough should connect the first input to a confirmed result and identify where human approval is required. If learning is part of the design, the walkthrough also needs to show what changes after feedback and how later responses will be tested.
If you’re adding an agent to an existing product, our AI integration services connect it to the data and systems it will use. We set access rules and test how it behaves before launch.