Source: AIML.com Research
Introduction
A traditional interaction with a language model is usually linear: you provide a prompt, the model generates a response, and the interaction ends.
An AI agent can work differently. Instead of deciding everything at once, it can take an action, inspect what happened, and use that result to decide what to do next.
This repeated process is the agentic loop.
A useful way to represent it is:
Perceive → Reason → Act → Observe → Refine → Repeat
The terminology varies across agent systems, but the underlying principle is consistent: the environment provides feedback after an action, and that feedback influences the agent’s next decision.
OpenAI, for example, describes computer-using agents as operating through an iterative cycle that combines perception, reasoning, and action. (Ref: Unrolling the Codex Agent Loop by Bolin)
How the Agentic Loop Works
Consider an agent given this goal:
Find a hotel near Times Square for under $200 per night.
The agent does not necessarily know in advance which hotel will satisfy the request. Instead, it discovers what to do through repeated interactions with its environment.
1. Perceive
The agent first gathers the information currently available.
At the beginning, that may simply be the user’s request. During later iterations, it can also include information returned by tools or earlier actions.
Here, the agent identifies two important constraints: the hotel should be near Times Square and cost less than $200 per night.
2. Reason
Using the current information, the agent determines what should happen next.
It might recognize that hotel prices and availability change, so relying only on information already contained in the model would be unreliable. The next useful step is therefore to retrieve current hotel listings.
Reasoning at this stage does not need to produce a complete plan. It can simply determine the next action that moves the task forward.
3. Act
The agent then interacts with its environment.
For example, it might call a hotel-search service using the requested location, dates, and price range.
Depending on the task, an action might instead involve searching for information, querying a database, running code, or interacting with another software system.
4. Observe
The action produces a result.
Suppose the hotel search returns several properties, but every available option near Times Square costs more than $200.
That result becomes a new observation. The important point is that the agent now knows something it did not know when the task began.
5. Refine
The agent uses the new observation to revise its next decision.
Instead of performing the same search again, it might expand the search radius, inspect nearby neighborhoods, or try another source.
The process then continues:
new information → new decision → new action → new information
until the task succeeds or a stopping condition is reached.
Why Feedback Changes the Process
Feedback is what makes the loop fundamentally different from generating a fixed sequence of steps upfront.
Suppose the model generates the entire sequence upfront:
Search hotels near Times Square → choose the best option → book it
If the search returns no hotels under $200, the next two steps are no longer valid. There is no acceptable option to choose or book.
An agentic system can instead inspect the search results first and adapt. For example, by expanding the search radius or trying a nearby neighborhood before deciding what to do next.
This pattern appears clearly in the ReAct framework introduced by Yao et al. Rather than separating reasoning from interaction, ReAct interleaves reasoning traces with actions and observations from an external environment. Those observations provide new information that can be used to update subsequent reasoning and handle unexpected results. (Ref: ReAct: Synergizing Reasoning and Acting in Language Models by Yao et al.)
The key distinction is therefore not simply that agents can perform multiple steps. It is that later steps can depend on what actually happened during earlier ones.
What the Loop Looks Like in Code
At its simplest, an LLM-based agent can be thought of as a model running inside a loop:
messages = [{"role": "user", "content": goal}]
for _ in range(max_steps):
response = model(messages)
if response.is_final:
break
result = execute_tool(response.tool_call)
messages.append(response)
messages.append({
"role": "tool",
"content": result
})The important line is not the for loop itself. It is the fact that the tool result is added back into the context before the model runs again.
The model therefore does not need to predict every step at the beginning. It chooses an action, receives evidence about what happened, and makes its next decision with more information.
Real implementations add tool schemas, error handling, permissions, context management, and other controls, but the underlying feedback pattern remains the same. OpenAI’s description of the Codex agent loop shows this in practice. The model produces a tool call, the surrounding agent harness executes it, and the tool output is then passed back into the model for the next inference step. (Ref: Unrolling the Codex Agent Loop by Bolin)
Source: OpenAI, “Unrolling the Codex Agent Loop,” 2026.
When Does the Loop Stop?
An agent should not continue indefinitely.
The loop normally ends when the agent determines that the goal has been reached or when another stopping condition is triggered. Practical implementations can also impose limits such as a maximum number of turns or actions to prevent unproductive loops.
The central idea is simple:
Act, observe what changed, and use that evidence to decide what happens next.
That feedback loop allows an agent to adapt while a task is being performed rather than relying entirely on decisions made before execution begins.
Videos
- This video “Finally. Agent Loops Clearly Explained.” by Nate Herk explains the agent loop as a repeated reason → act → observe process that continues until a stopping condition is met. It is especially useful for this article because it emphasizes that iteration alone is not enough: the agent also needs a way to verify whether the task is actually complete. That connects directly to the article’s sections on feedback and stopping conditions. (Runtime:14:34)
References
- Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023). ReAct: Synergizing Reasoning and Acting in Language Models. International Conference on Learning Representations (ICLR).
- Bolin, M. (2026). Unrolling the Codex Agent Loop. OpenAI.