The agent is still running. The screen still scrolls. It fixes one spot, runs again, sees it's not right, fixes again — same spot, same way. A second time. A third. By the fourth you freeze and realize: it hasn't moved an inch past where it was ten minutes ago. It isn't standing still — it's walking in a circle, and you're paying for each lap as if it were progress.
This is a strange kind of break. It isn't silent the way that stops and reports done. It's silent the way that's loud — there's always activity to watch, so the lack of progress hides under a layer of busyness.
01Why it can't see itself circling
To fix it, you have to understand why it can't escape on its own. The agent decides one step at a time, based on what's right in front of it. And at each step, the move it picks is locally reasonable: "the result isn't right yet, let me try fixing this spot" — a perfectly sensible sentence if you look at that step alone.
What it lacks is the view from above. It doesn't step back to see that this step is identical to the one two laps ago, that the whole chain is drawing a circle instead of a line. Each decision is right where it stands, but stacked together they're wrong overall — and the agent lives inside that "where it stands," with no panorama. That's exactly where you come in: the repeating pattern, seen from above, is something only you can see, not it.
All three share one thing: none of them is an error line. That's why a loop is more dangerous than a crash — a crash stops and screams, a loop keeps going and whispers "almost there."
02The exit isn't more instruction — it's interrupt and restart
The wrong reflex on seeing a loop is to type one more line: "try something different," "don't redo what you just did." But that pours more words into the very context that trapped it. It still looks at the same old pile of information, so it still walks the same old circle. You can't undo a loop from inside the loop.
The way out is to leave it entirely, in three beats:
Beat 2 — Interrupt and reset: stop now, clear the context that trapped it. Nobody undoes a loop from inside the loop.
Beat 3 — Re-hand: same problem, fresh desk, with one explicit stop condition.
The middle beat is the most important and the most skipped: you have to clear the context. Re-handing it inside the same old conversation drags along every circle it just walked — only a clean desk breaks the thread.
When you re-hand it, add the one thing it lacked: a stop condition. Instead of "fix it until it runs," say "try at most two approaches; if neither works, stop and describe what you tried and where you're stuck." That sentence gives the agent what it can't supply itself — a brake, a definition of "when to give up and ask." You're lending it the view from above that it doesn't have.
03The longer you let it run, the more the circle costs
A loop bites hardest exactly when you aren't watching. When you supervise each step, you interrupt after the second lap. But let an agent run in the background, or a long automated chain run unattended, and the circle spins dozens of times before anyone glances over — and each spin is real tokens, real time, poured into a standstill. The final output is just as wrong as it was on lap one; you've only paid extra for it to be wrong longer.
So the thing worth building in is not "make the agent smart enough not to get stuck" — getting stuck is the nature of something that only sees what's in front of it. The thing worth building in is a stop condition, from the start, for anything you mean to let it run far. A vehicle with no brakes is meaningless however fast it goes, if all it's doing is circling a track. Your job is to draw the stop line before you let it roll.