What is an agentic loop?

An agentic loop is the repeating cycle an AI agent runs to complete a task: gather context, reason about the next action, act (usually by calling a tool), observe the result, and repeat until the goal is met or a stop condition fires. It is the core mechanism that separates an agent — which iterates and adapts to feedback — from a single-shot model that answers once.

What's the difference between an agent loop and a workflow?

In a workflow, a human writes the steps in code and the LLM fills in pieces along a predefined path. In an agent loop, the model itself decides what to do next at each turn based on what it observes — it directs its own tool use. Workflows are more predictable; agent loops are more flexible. Most production systems combine both: workflows for the well-understood parts, agent loops where the path can't be hardcoded.

How do you stop an agentic loop from running forever?

Production agents use several guardrails at once: a max-iteration cap (often 10–25 steps), a token budget per run, a wall-clock timeout, repeated-action detection (the agent is stuck doing the same thing), and a human-in-the-loop gate for irreversible or high-cost actions. A well-built agent usually halts on its own when the task is done; these are the safety nets for when it doesn't.

What is the ReAct loop?

ReAct (Reasoning + Acting) is the most common agent loop pattern: the model alternates between a reasoning step (thinking through the problem) and an acting step (calling a tool), feeding each observation back into the next thought. The Thought → Action → Observation cycle keeps the agent grounded in real tool results and is the default shape of most tool-using agents today.

What is context engineering (and harness engineering)?

Context engineering is the practice of deciding what to put in the model's context window at each turn of the loop — instructions, retrieved evidence, prior results, and state — so the model has what it needs without drowning in noise (a failure mode called context rot). Harness engineering is the broader discipline of building the code around the model: validating tool calls, enforcing permissions and budgets, managing memory, and controlling when the loop stops. As models have gotten stronger, the harness and its context have become where most agent reliability is won or lost.

Agentic loop vs. agentic workflow vs. agentic AI — what's the difference?

Agentic AI is the umbrella term for systems that plan, use tools, and act autonomously. An agentic loop is the atomic mechanism inside such a system — the observe-reason-act-observe cycle of a single agent. An agentic workflow is the outer orchestration that coordinates one or more agents, tools, and humans toward a larger outcome. Loop is the engine; workflow is the assembly line; agentic AI is the category.

Concept · AI Agents

What Are Agentic Loops? The Core Pattern Behind Every AI Agent

An agentic loop is the cycle that turns a language model into an agent. Instead of answering in one shot, the model runs a repeating loop: it gathers context, reasons about what to do next, takes an action (usually a tool call), observes the result, and feeds that result back in — iterating until the goal is met or a stop condition fires. That feedback loop is the whole difference between a chatbot and an agent.

ReActReflectionPlan-and-ExecuteOrchestrator–WorkersEvaluator–OptimizerTree of Thoughts

Agent vs. workflow vs. single-shot

A single-shot call answers once: prompt in, answer out, no feedback. Useful, but it can't recover from a wrong assumption because it never sees a result.

A workflow wraps the model in code you wrote: predefined steps, with the LLM filling in pieces along a fixed path. Predictable, but only as flexible as the path you hardcoded.

An agent runs a loop where the model itself decides the next action based on what it just observed. As Anthropic puts it, agents are “just LLMs using tools based on environmental feedback in a loop.” That feedback loop — gaining ground truth from the environment at each step — is what makes an agent able to handle tasks you couldn't script in advance.

The agentic loop, step by step

Every agent — from a coding assistant to a voice agent — runs some version of this five-step cycle.

1Gather context
2Reason & decide
3Act
4Observe

Repeat until the goal is met — or a stop condition fires.

1
Gather context
Assemble what the model needs to decide its next move — the goal, the conversation so far, retrieved documents, prior tool results, and the current state of the world — into the context window. Deciding what to include (and what to leave out) is the practice now called context engineering.
2
Reason & decide
The model thinks about the current state and chooses a single next action. In a well-built agent it does not call the tool itself — it returns a structured tool call describing what it wants to do.
3
Act
The harness (the code around the model) validates that tool call against a schema, checks permissions, and executes it — running code, querying an API, editing a file, sending a message. The harness is the gate; the model never touches systems directly.
4
Observe
The result of the action — a tool output, an error, a changed file, a test result — is captured and fed back into the context as ground truth. This observation is what keeps the agent grounded in reality rather than its own assumptions.
5
Repeat or stop
With the new observation in hand, the loop runs again. It keeps iterating until the task is done — or until a stop condition trips: a max-iteration cap, a token budget, a timeout, a repeated-action detector, or a human-in-the-loop approval gate.

The harness, not the model, runs the loop. A production agent never lets the model call tools directly — the model returns a structured tool call, and the surrounding code validates the schema, checks permissions, executes it, and injects the result back. That outer code is the harness, and engineering it well is most of the job. See how the Claude Agent SDK runs this loop →

What the loop looks like in practice

Three real agent types, one iteration trace each. Notice the loop only stops when the goal is met — or a safeguard hands off to a human.

Fix a failing test

Coding agent →

Gather: read the failing test and the function under test.
Reason: the loop bound looks off by one.
Act: edit the function and run the test suite (tool call).
Observe: one assertion still red — the fix was wrong.
Reason + Act: adjust the boundary, run the suite again.
Observe: all tests green.

Goal met — tests pass, so the loop halts on its own.

Qualify and book an inbound lead

Sales agent →

Gather: read the inbound form; pull the contact from the CRM (tool).
Reason: company size is missing — can't qualify yet.
Act: call the enrichment API (tool).
Observe: 200 employees, matches the ICP.
Act: draft a personalized reply and check calendar availability (tool).
Act: send the reply and log the task in the CRM (tool).

Goal met — or escalate to a human rep if the lead is off-ICP or high-value.

Resolve a 'where is my order?' ticket

Support agent →

Gather: read the ticket; classify the intent as order-status.
Act: fetch the order from the commerce API (tool).
Observe: shipped, but tracking shows a carrier delay.
Act: search the knowledge base for the delay policy (tool).
Act: draft a reply with the tracking link and the policy, and post it.

Goal met — but hand off to a human if the customer asks for a refund above the auto-approve threshold.

The named loop patterns

Most “agent architectures” are variations on the base loop. These are the patterns you'll see named again and again — and the ones worth knowing before you build.

ReAct (Reasoning + Acting)

The agent alternates between a reasoning step (think about the problem) and an acting step (call a tool), feeding each observation back into the next thought.

How it loops: Thought → Action → Observation, repeated. The model writes a short reasoning trace, emits one tool call, reads the result, then reasons again. It is the default shape of most production agents.
When to use: The reliable default for tool-using agents on multi-step tasks. Reach for something heavier only when ReAct's greedy, one-step-at-a-time behavior starts thrashing on tasks that need an upfront plan.
Example: A data agent asked 'why did signups drop last week?' reasons it needs the numbers, queries the warehouse, observes a dip isolated to mobile, reasons again, checks the release log, and finds a broken signup button shipped Tuesday.

Definition: ReAct (Reasoning + Acting) →Source: Yao et al., arXiv (2022)

Reflection (self-critique)

The agent generates an output, critiques its own work against the goal, and revises — looping on its own feedback before returning a result.

How it loops: Generate → Critique → Revise, repeated. A second pass (sometimes a separate 'critic' role) inspects the draft for errors and missing requirements, and the agent loops until the critique is clean or a cap is hit.
When to use: Tasks where a first draft is rarely right — code that must compile, analysis that must be complete, writing that must hit a spec. Skip it for simple lookups where reflection just burns tokens.
Example: A coding agent writes a function, runs the test suite, reads two failing assertions, and revises — repeating until the tests pass instead of handing over code it never executed.

Definition: Reflection Pattern →Source: Shinn et al., arXiv (2023)

Plan-and-Execute

The agent first decomposes the goal into an explicit plan of sub-tasks, then executes each one — re-planning when reality diverges from the plan.

How it loops: Plan → Execute step → Observe → (re-plan if needed) → next step. Separating planning from execution keeps long tasks coherent and makes the agent's intent auditable.
When to use: Long, multi-stage tasks where greedy step-by-step agents lose the thread or repeat work. The overhead is wasted on short tasks that ReAct handles in a few steps.
Example: An operations agent handling an incident plans: pull the alert, identify the failing service, check recent deploys, draft a rollback, notify the channel — then executes each step, re-planning when the rollback reveals a second root cause.

Definition: Cognitive Architecture →Source: Lilian Weng (2023)

Orchestrator–Workers

A central orchestrator agent breaks the task down and delegates sub-tasks to specialized worker agents, then synthesizes their results.

How it loops: The orchestrator runs its own loop — decide which worker to invoke next, dispatch, collect the result, decide again — while each worker runs an inner loop on its scoped sub-task.
When to use: Tasks that split cleanly into specialized sub-jobs (research, drafting, review) or that benefit from parallel workers. It adds coordination overhead, so it is overkill for anything one agent can finish alone.
Example: A marketing request 'launch a campaign for the new feature' is split by an orchestrator across a research worker, a copy worker, and a design-brief worker, then assembled into one plan.

Definition: AI Orchestrator →Source: Anthropic (2024)

Evaluator–Optimizer

One model generates a candidate answer while a second model evaluates it against criteria; the loop optimizes the output across rounds.

How it loops: Generate → Evaluate against a rubric → feed the evaluation back → regenerate. Unlike plain reflection, the evaluator is a distinct role with explicit criteria, which makes the loop's stopping rule concrete.
When to use: When you have clear evaluation criteria and a first attempt usually falls short — translation quality, search relevance, code that must satisfy a spec. Needs a measurable rubric to be worth the extra calls.
Example: A support agent drafts a reply; an evaluator scores it for accuracy and tone against the brand guide and rejects vague answers, looping until the draft clears the bar.

Definition: Agent Evaluation →Source: Anthropic (2024)

Tree of Thoughts

The agent explores several reasoning paths in parallel, evaluates the branches, and pursues the most promising — searching instead of committing to one line of thought.

How it loops: Branch → evaluate each branch → prune → expand the best, repeated. It generalizes chain-of-thought from a single line into a searchable tree, trading more compute for better answers on hard problems.
When to use: Hard reasoning, planning, and search problems where a single greedy chain gets stuck. It is expensive — most everyday agent tasks do not need it.
Example: A planning agent solving a constrained scheduling puzzle explores several candidate orderings, scores how many constraints each satisfies, and expands the best branch rather than backtracking from one dead end.

Definition: Chain-of-Thought (CoT) →Source: Yao et al., arXiv (2023)

Worth noting: prompt chaining, routing, and parallelization are often listed alongside these, but they're workflow patterns — orchestrated by code, not driven by the model's own loop. The line between a workflow and an agent is exactly who decides the next step.

Loop control: where agents are won or lost

Each iteration costs tokens, time, and money — and a loop with no brakes is a runaway bill. The hard problems in agent engineering are about controlling the loop:

Stop conditions. Max-iteration caps, token budgets, and timeouts so the loop can't run forever.
Repeated-action detection. Catch the agent looping on the same failing move and break out or escalate.
Context engineering. Curate what goes into the window each turn — too much and the model degrades (context rot); too little and it loses the thread.
Human-in-the-loop gates. Require approval for irreversible or high-cost actions — sending money, deleting data, publishing.

For concrete stop-condition knobs — max turns, budget caps, context compaction — see the Claude Agent SDK agent-loop docs; for a practical take on designing and sandboxing loops, Simon Willison's Designing agentic loops is the reference.

Related concepts

Short definitions for the terms that surround the agentic loop.

Agentic Loop Agent Loop ReAct (Reasoning + Acting)Reflection Pattern Tool Use Orchestration AI Orchestrator Human-in-the-Loop (HITL)Context Window Multi-Agent System Agentic Workflow Agentic AI Cognitive Architecture Chain-of-Thought (CoT)Model Context Protocol (MCP)Agent Memory

Agent types built on these loops

The patterns above aren't academic — they're what these production agents run on.

Sources & further reading

The primary sources behind the definitions and patterns on this page.

Building Effective Agents— Anthropic, 2024
How the Agent Loop Works (Claude Agent SDK)— Anthropic, 2026
Unrolling the Codex agent loop— OpenAI, 2025
ReAct: Synergizing Reasoning and Acting in Language Models— Yao et al., arXiv, 2022
Reflexion: Language Agents with Verbal Reinforcement Learning— Shinn et al., arXiv, 2023
Tree of Thoughts: Deliberate Problem Solving with LLMs— Yao et al., arXiv, 2023
LLM Powered Autonomous Agents— Lilian Weng, 2023
Designing agentic loops— Simon Willison, 2025
What Is the AI Agent Loop? The Core Architecture Behind Autonomous AI Systems— Oracle, 2025
Agent Loop (runtime lifecycle)— OpenClaw, 2026

Frequently asked questions

What is an agentic loop?
An agentic loop is the repeating cycle an AI agent runs to complete a task: gather context, reason about the next action, act (usually by calling a tool), observe the result, and repeat until the goal is met or a stop condition fires. It is the core mechanism that separates an agent — which iterates and adapts to feedback — from a single-shot model that answers once.
What's the difference between an agent loop and a workflow?
In a workflow, a human writes the steps in code and the LLM fills in pieces along a predefined path. In an agent loop, the model itself decides what to do next at each turn based on what it observes — it directs its own tool use. Workflows are more predictable; agent loops are more flexible. Most production systems combine both: workflows for the well-understood parts, agent loops where the path can't be hardcoded.
How do you stop an agentic loop from running forever?
Production agents use several guardrails at once: a max-iteration cap (often 10–25 steps), a token budget per run, a wall-clock timeout, repeated-action detection (the agent is stuck doing the same thing), and a human-in-the-loop gate for irreversible or high-cost actions. A well-built agent usually halts on its own when the task is done; these are the safety nets for when it doesn't.
What is the ReAct loop?
ReAct (Reasoning + Acting) is the most common agent loop pattern: the model alternates between a reasoning step (thinking through the problem) and an acting step (calling a tool), feeding each observation back into the next thought. The Thought → Action → Observation cycle keeps the agent grounded in real tool results and is the default shape of most tool-using agents today.
What is context engineering (and harness engineering)?
Context engineering is the practice of deciding what to put in the model's context window at each turn of the loop — instructions, retrieved evidence, prior results, and state — so the model has what it needs without drowning in noise (a failure mode called context rot). Harness engineering is the broader discipline of building the code around the model: validating tool calls, enforcing permissions and budgets, managing memory, and controlling when the loop stops. As models have gotten stronger, the harness and its context have become where most agent reliability is won or lost.
Agentic loop vs. agentic workflow vs. agentic AI — what's the difference?
Agentic AI is the umbrella term for systems that plan, use tools, and act autonomously. An agentic loop is the atomic mechanism inside such a system — the observe-reason-act-observe cycle of a single agent. An agentic workflow is the outer orchestration that coordinates one or more agents, tools, and humans toward a larger outcome. Loop is the engine; workflow is the assembly line; agentic AI is the category.

We build agents on these patterns

Knowing the loop is one thing; shipping a reliable one is another. Tell us your use case and we'll scope the right agent — loop control, tools, and guardrails included.

Loading…

What Are Agentic Loops? The Core Pattern Behind Every AI Agent

Agent vs. workflow vs. single-shot

The agentic loop, step by step

Gather context

Reason & decide

Act

Observe

Repeat or stop

What the loop looks like in practice

Fix a failing test

Qualify and book an inbound lead

Resolve a 'where is my order?' ticket

The named loop patterns

ReAct (Reasoning + Acting)

Reflection (self-critique)

Plan-and-Execute

Orchestrator–Workers

Evaluator–Optimizer

Tree of Thoughts

Loop control: where agents are won or lost

Related concepts

Agent types built on these loops

AI Coding Agent

AI Sales Agent

AI Support Agent

AI Data Analyst Agent

AI Operations & IT Agent

Sources & further reading

Frequently asked questions

What is an agentic loop?

What's the difference between an agent loop and a workflow?

How do you stop an agentic loop from running forever?

What is the ReAct loop?

What is context engineering (and harness engineering)?

Agentic loop vs. agentic workflow vs. agentic AI — what's the difference?

We build agents on these patterns

What Are Agentic Loops? The Core Pattern Behind Every AI Agent

Agent vs. workflow vs. single-shot

The agentic loop, step by step

Gather context

Reason & decide

Act

Observe

Repeat or stop

What the loop looks like in practice

Fix a failing test

Qualify and book an inbound lead

Resolve a 'where is my order?' ticket

The named loop patterns

ReAct (Reasoning + Acting)

Reflection (self-critique)

Plan-and-Execute

Orchestrator–Workers

Evaluator–Optimizer

Tree of Thoughts

Loop control: where agents are won or lost

Related concepts

Agent types built on these loops

AI Coding Agent

AI Sales Agent

AI Support Agent

AI Data Analyst Agent

AI Operations & IT Agent

Sources & further reading

Frequently asked questions

What is an agentic loop?

What's the difference between an agent loop and a workflow?

How do you stop an agentic loop from running forever?

What is the ReAct loop?

What is context engineering (and harness engineering)?

Agentic loop vs. agentic workflow vs. agentic AI — what's the difference?

We build agents on these patterns