The shortest answer is this:
An agentic loop is a bounded feedback loop with runtime next-step choice.
That is the real dividing line.
Not every loop is agentic. A workflow can loop. A retry policy can loop. A polling job can loop. A piece of automation can repeat the same steps for hours. None of that, by itself, makes the system an agent.
What changes in an agentic loop is that the system can inspect the current state, look at what just happened, choose what to do next, and continue toward a goal without following one fully prewritten path.
If you want the broader definition of an agent first, start with What Is an AI Agent?. If you want the larger comparison across system types, see LLMs, Workflows, and Agents: What Actually Changes?. This article answers the mechanism question inside those definitions and shows when this kind of loop is worth using.
Why Not Every Loop Is Agentic
The word loop causes a lot of confusion because software loops are everywhere.
Examples:
- retry the API call three times
- poll the payment provider every thirty seconds
- keep checking the inbox for new messages
- run the next workflow step until the queue is empty
All of those are loops. All of them may be useful. None of them are necessarily agentic.
Why not?
Because the path is still effectively owned by the designer.
The system may repeat, branch, or wait, but it is not actually deciding among meaningful next actions based on what it just learned. It is still executing a script.
A simple refund workflow makes the contrast clear.
A scripted loop might do this:
- read the refund request
- check order status
- if the order is eligible, issue refund
- if the order is not eligible, send denial template
- if the payment API times out, retry three times
That may be excellent software. It is still a workflow.
An agentic loop would face a different kind of task. It might inspect the request, pull the order history, check shipment events, compare prior support interactions, decide whether it needs policy documentation, ask for missing information, escalate if the risk is high, or stop if the evidence is clear. The important change is not that it loops. The important change is that it chooses the next step during the run.
The Agentic Loop Test
The cleanest way to judge this is with a simple framework:
A loop is agentic only if it passes the Agentic Loop Test.
The test has four parts.
1. State
The loop must have a usable view of the current task state.
That does not always mean long-term memory. It can be short-term working context for one run. But the system has to know enough about what has happened, what remains unresolved, and what constraints apply.
If every step is effectively amnesiac, you do not have much of a loop. You have repeated isolated calls.
2. Choice
The loop must be able to choose among plausible next actions at runtime.
This is the decisive property.
If the developer already encoded the path ahead of time, including every meaningful next step, the system is still a workflow. If the system can decide whether to search, ask a follow-up, call a tool, try a different tool, escalate, or stop based on the live state of the task, you are in agent territory.
3. Feedback
The loop must use the result of each action to shape what happens next.
This is what turns a repeated cycle into a control loop.
If a tool call fails, the system should not only repeat blindly. It should interpret the failure. If a search returns weak evidence, the system should know that it needs a different query or a different source. If a result is good enough, it should continue or stop.
4. Goal-Bounded Termination
The loop must stop because the goal is met, confidence is too low, policy blocks the next action, or a designed limit is reached.
That matters because endless repetition is not agency. It is lack of control.
A real agentic loop does not just know how to continue. It also knows when to stop, when to hand off, and when it is no longer safe to keep acting.
What Runtime Choice Actually Means
The phrase runtime choice can sound abstract, so it helps to make it concrete.
It does not mean the system has unlimited freedom.
It means the system has bounded discretion about the next step.
Consider incident triage.
A workflow version might look like this:
- pull the latest alert
- query the service health endpoint
- if health check fails, page team A
- if health check passes, close the ticket
Again, that may be perfectly correct for a narrow environment.
An agentic version would look different:
- inspect the alert and the surrounding system context
- decide whether the failure looks like infrastructure, application, dependency, or data drift
- choose which log source, dashboard, or runbook to inspect next
- update the working hypothesis after each observation
- escalate to a human if the evidence is conflicting or the next action is risky
- stop when the system has enough confidence to recommend or take the next approved action
The agentic part is not the presence of logs, tools, or multiple steps. The agentic part is that the next move is chosen during the loop rather than fixed ahead of time.
That is why a useful question is:
After each step, who owns the next-step decision?
If the answer is the workflow graph, you are mostly in workflow territory.
If the answer is the system, inside explicit boundaries, based on what just happened, you are closer to an agentic loop.
Deterministic Loop vs Agentic Loop
The comparison is easier to scan in table form:
| Dimension | Deterministic loop | Agentic loop |
|---|---|---|
| Main driver | Predefined script | Goal-directed runtime choice |
| What repeats | Steps the designer already chose | A decision cycle that may choose different steps |
| Reaction to failure | Retry or fallback branch | Retry, replan, switch tools, ask, escalate, or stop |
| State use | Usually passed through fixed steps | Read and updated to guide the next move |
| Tool use | Prewired tool calls | Tool choice can be conditional and dynamic |
| Stop condition | End of script or fixed limit | Goal met, confidence too low, policy boundary, or limit reached |
| Operational risk | Lower and easier to audit | Higher and harder to evaluate |
This is why loop alone is not a useful definition.
A deterministic loop repeats a path. An agentic loop repeats a decision cycle.
That difference is the center of the article.
Why Tool Use, Memory, and Reflection Matter
People often reach for the wrong signals when deciding whether something is agentic.
Tool Use Is Important, But Not Sufficient
A system can call tools without being agentic.
A workflow that always:
- queries a CRM
- sends an email
- writes a record to a database
is still a workflow if those steps are fixed.
Tool use matters because it lets the system act in the world. But tool use does not settle the question. The better question is whether the loop can choose which tool to use next and why.
Memory Supports the Loop, But Memory Alone Is Not the Definition
A loop usually needs at least short-term state to stay coherent. It has to remember what it tried, what it found, and what constraints apply.
But memory alone does not create agency.
A workflow can maintain state across many steps and still remain fully scripted. Memory helps an agentic loop work. It is not the sole property that makes it agentic.
Reflection Matters Because It Closes the Loop
Reflection is the practical expression of feedback.
It means the system does not only act. It also inspects results and updates its next move. That is why patterns like reason-act-observe and related loop designs matter so much in agent engineering. They make the system responsive to the environment instead of mechanically obedient to a static path.
This is also one reason Why Agent Engineering Is Becoming Its Own Discipline argues that the hard problem is no longer the prompt alone. The engineering problem is the loop around the model.
Why Bounded Autonomy Matters
In theory, you could define an agentic loop as open-ended adaptation in pursuit of a goal.
In practice, that is not enough.
Useful systems need bounded autonomy.
That means the loop is constrained by:
- approved tools
- typed inputs and outputs
- cost and time limits
- explicit stop conditions
- escalation rules
- human approval checkpoints for meaningful side effects
This matters because the same property that makes the loop powerful also makes it riskier. Once the system can decide what to do next, it can choose well or choose badly.
So the production version of the answer is:
The loop becomes agentic when it can choose the next action from feedback and state, and it becomes usable when that choice is bounded by policy, permissions, and stopping rules.
That is the design target.
When You Still Only Need a Workflow
One reason the term agentic gets overused is that people describe any multi-step AI system as an agent to make it sound more advanced.
That is usually a mistake.
You still want a workflow when:
- the path is known in advance
- the valid branches are small and stable
- the task is easy to express as explicit rules
- auditability matters more than flexibility
- the cost of a wrong next-step decision is high
You want an agentic loop when:
- the task is multi-step and uncertain
- the right next action depends on what happens during execution
- the system may need to choose among several tools or strategies
- the path cannot be fully hardcoded without becoming brittle
The practical rule is still the same:
Use the smallest amount of autonomy the task actually needs.
That often means starting with a workflow, then adding one narrow agentic loop only where uncertainty is real.
FAQ
Is any software loop with retries or branches an agent loop?
No. Retries, polling, and branching can all exist inside ordinary automation. The loop becomes agentic only when the system can inspect outcomes and choose among meaningful next actions at runtime.
What exact loop property makes a system agentic?
The decisive property is bounded runtime next-step choice under feedback. The system sees state, evaluates what just happened, and decides what to do next toward a goal.
Does tool use make something agentic?
No. Tool use is necessary for many practical agents, but a fixed sequence of tool calls is still just a workflow.
Does memory make something agentic?
No. Memory helps maintain continuity across the loop, but a stateful workflow can still be fully scripted.
What is the difference between a workflow loop and an agentic loop?
A workflow loop repeats a predefined path. An agentic loop repeats a decision cycle, and that cycle may choose different next actions depending on the live state of the task.
What does runtime choice actually mean?
It means the system has bounded discretion over the next step during execution. It does not have to follow one fully predetermined sequence.
If the system asks follow-up questions, is it an agent?
Not automatically. Asking a follow-up can be scripted. The bigger test is whether the system can choose among several actions or strategies based on state and feedback.
Can a workflow contain one agentic step?
Yes. Many good production systems are hybrids. A workflow can own the outer structure while one bounded agentic loop handles the ambiguous middle part.
What is the smallest useful agentic loop?
A narrow loop with one clear goal, a small allowed tool set, short-term task state, explicit stop conditions, and escalation to a human when confidence is low.
Why does bounded autonomy matter?
Because otherwise the same loop that adapts can also spin, overspend, or take unsafe actions. Boundaries are part of the system design, not optional polish.
What gets harder once the loop becomes agentic?
Evaluation, observability, permissions, failure analysis, and cost control all get harder because you are no longer judging one output or one fixed path. You are judging a trajectory.
What should I read next after this?
If you want the broader definition, read What Is an AI Agent?. If you want the architecture comparison, read LLMs, Workflows, and Agents: What Actually Changes?. The next useful topics after that are planning, tool use, memory, and the specific reasoning patterns that run inside the loop.