What Is an Agentic Loop?

“Agent” and “agentic” get thrown around so much they’ve nearly stopped meaning anything, which is a shame, because the underlying idea is genuinely simple and genuinely important. An agentic system is one where an LLM isn’t just answering a question — it’s making decisions inside a loop: take an action, look at what happened, decide the next action, repeat until the goal is met or something stops it. That’s the whole concept. And the reason it’s worth understanding precisely is that once you see the loop, you understand why reliability comes from the loop, not from the model.

One-shot vs the loop

The familiar way to use an LLM is one-shot: prompt in, answer out. You ask, it responds, you’re done. Useful, but bounded — the model can only give you its best single guess from what you handed it, and it can’t check whether that guess was any good, gather more information, or correct course.

An agentic loop breaks that open by putting the model in the driver’s seat of a multi-step process:

1. Act — the model chooses and takes an action (run a command, call a tool, edit a file, query something).
2. Observe — it sees the result of that action (the output, the error, the new state).
3. Decide — based on what it observed, it chooses the next action toward the goal.
4. Repeat — until the goal is reached, or a limit stops it.

That’s it. The model stops being an oracle you consult once and becomes a decision-maker steering a process over many steps. “Fix this bug” stops being “here’s what I’d try” and becomes: try it, see the test fail, read the error, adjust, try again, see it pass. The loop is what turns advice into work.

A chatbot answers. An agent acts, looks, and adjusts. The difference isn’t a smarter model — it’s the loop wrapped around it.

The loop matters more than the model

Here’s the insight that reorganized how I think about this: the reliability of an agentic system depends far more on the loop than on which model is inside it. A strong model in a sloppy loop produces confident, expensive nonsense. A modest model in a well-designed loop produces useful, correct work. The loop is where the engineering actually lives, and it’s a small set of questions:

• What work is it given? The context and tools it can see each step — its durable context and the tools it can reach shape every decision it makes.
• How is each step verified? Whether an external, objective signal tells it if a step actually helped — the difference between a loop that converges and one that drifts.
• When does it stop? The conditions and limits that end the loop — without which it dies in one of a few predictable ways.

Get those right and the model is almost interchangeable. Get them wrong and no model saves you.

It improves in-context, not by learning

A common misconception is that an agent “learns” as it works. It doesn’t — not in the training sense. The model’s weights are frozen. What improves during a run is the context: as the loop feeds it results, errors, and observations, it has more to reason from, so its later decisions are better- informed than its early ones. That’s why context management is central to agentic systems, and why a long-running loop needs somewhere durable to keep its progress — a handoff file it reads first and writes last — because when the run ends, that hard-won context evaporates unless it was written down.

Why the concept is worth holding precisely

Naming the loop clearly does two things. It cuts through the hype: “agentic” isn’t magic, it’s a control loop with an LLM as the controller, and you can reason about it like any other control system — inputs, feedback, stopping conditions. And it points your effort at the right place: if an agent is underperforming, the fix is almost never “use a bigger model,” it’s “fix the loop” — better context, a real verification signal, sane stop conditions, maybe a separate checker so it isn’t grading its own work. Once you see agentic systems as loops, they stop being mysterious and start being engineerable, which is the whole point of understanding them. If you’re building agentic loops and have found the loop matters more than the model too, I’d like to compare notes.