Everyone is talking about agentic loops right now. Far fewer people can tell you what one actually is.
The concept is simple. You hand the agent a goal and it keeps working, turn after turn, deciding for itself when the job is done. Claude Code's /goal is a clean example: it iterates, and a separate model checks each turn against the goal until it passes. People also point to /loop and "routines", but /loop is closer to scheduled automation, re-running a prompt on a timer. Useful, just not the same animal as an agent reasoning its way to a finish line.
I've been running these loops on real work, and when the conditions are right the results are really impressive. The catch is that for most teams, most of the time, the conditions are not right.
So when is a loop actually worth it?
Experimentation and prototyping. When you're exploring and the details don't matter yet, letting the agent fill the gaps is the whole point. You want speed and direction. If it picks a slightly wrong library or names things oddly, who cares, you're throwing most of it away anyway.
When your token budget is effectively unlimited. Loops are expensive by design. The agent re-runs, re-reads, and burns credits on every turn it isn't sure about. A task a senior dev finishes in 20 minutes can cost a small fortune in tokens because the loop keeps second-guessing itself. If that doesn't scare you, fine. For most teams it should.
Maintenance work behind solid guardrails. This is the one people oversell. The pitch goes: you have a test suite and design docs, so the loop can run safely. Sometimes true. But a green test suite tells you the tests pass. It doesn't tell you the behavior is correct. If your guardrails don't actually encode intent, the loop will optimize for the wrong target and report success with a straight face. A loop is only as good as the fence you build around it.
This is where a good harness matters. The loop needs a way to check its own work, and the stronger that self-verification, the better the loop runs. For anything with a UI, the harness has to include visual checks. A loop that can see what it rendered catches whole classes of mistakes a green test run sails right past.
Look at those three again: an unlimited budget, work you'll throw away, and guardrails that truly capture intent. That's a narrow slice of real work. Miss all three and the loop is probably not for you, which is most real work.
Skip the loop when details matter. If the exact behavior, the edge cases, or the API shape are load-bearing, an agent guessing is exactly the failure mode you're trying to avoid. Keep a human in the loop and specify those parts yourself.
Skip it when the budget is real. Most teams have a cap. A loop that costs 10x a human for a predictable task is a bad trade, no matter how autonomous it feels.
And skip it on the critical path. For the parts of the system where a wrong decision is expensive, the human is the point. Take the human out and you've removed the one thing keeping the loop honest.
In short: agentic loops shine when being wrong is cheap and being fast is valuable. The moment correctness, cost, or risk enters the picture, the loop stops being a shortcut and turns into a liability. For most teams, most of the time, that's the situation you're in. So loops might not be for you, at least not yet.
Top comments (0)