The Four Ways an Autonomous Loop Dies

The appeal of an agent loop is obvious: give it a goal, let it work, walk away, come back to progress. The part nobody sells you is that a loop left alone fails in a handful of specific ways, and if you can’t name them in advance you’ll be diagnosing them at 3am with the meter running. The good news is the list is short. After running enough of these in my AI automation lab, I’ve come to think of it as four deaths — three the machine can catch for you, one only you can.

Runaway recursion: the loop that never stops asking for work

The first way a loop dies is by never dying. Two agents hand work back and forth, or one keeps finding “just one more thing” to do, and the cycle never reaches a natural end. Nothing is broken, exactly — it’s doing what you told it, forever. The failure is purely economic, and it’s the one that shows up as a horror story about a bill nobody noticed for days.

The cure is embarrassingly cheap: a hard step cap and a spend ceiling, set before the loop ever runs. “Stop after N turns, no exceptions.” “Stop when you’ve spent this much.” A single one of those limits turns an open-ended catastrophe into a job that quits on its own. You don’t need anything cleverer than a number and the discipline to set it first.

Silent death: dead for hours, still reporting progress

The second death is the sneaky one. A run fills its context window, or wedges on some step, and stops making real progress — but it still looks alive. Logs scroll, tokens burn, a status line ticks. You think it’s working. It’s been dead since breakfast.

A loop that can’t tell you it stopped is worse than one that crashes. A crash at least has the decency to be obvious.

The fix is a heartbeat. Have each iteration write a small “I’m still really working” signal, and alert on the absence of it. Pair that with fresh context per phase instead of one endless run that slowly suffocates in its own history. The heartbeat is what converts “silently stuck for six hours” into “paged after ten minutes.”

The random walk: motion without direction

The third death is drift. With no verifiable definition of done, a loop wanders. Each step looks locally reasonable, but there’s no gravity pulling it toward the goal, so it meanders — refactoring things that were fine, chasing tangents, “improving” its way sideways. It’s busy and going nowhere.

The cure is a stop condition the loop can’t argue with: a real, external check that is either satisfied or isn’t. A passing test suite is a fixpoint you can actually reach. “Looks done” is not — it’s an opinion, and an agent grading its own opinion will always give itself a passing grade. This is important enough that I gave it its own post: a loop without grounded feedback doesn’t converge, it drifts.

Comprehension debt: the death you can’t automate away

The first three are mechanical, and machines catch them — caps, heartbeats, verifiers. The fourth is human, and no tool will save you from it. The faster a loop ships code you didn’t write, the wider the gap between what your system does and what you understand. Let it run unread long enough and you stop being the engineer. You become a rubber stamp on a codebase that’s technically yours and functionally a stranger’s.

There’s no clever brake for this one. The only cure is a rule you enforce on yourself: a human-read gate the loop may never skip. You review what it produced, in small enough slices that reviewing is actually possible — which is the whole argument for small slices over big-bang generation. Comprehension debt is the price of the leverage, and you pay it down by reading, not by adding automation on top of automation.

Build the brakes before the horsepower

The through-line: every one of these is cheap to prevent and expensive to discover in production. So the order matters — you install the brakes before you let the thing run unattended, not after the first scare. A step cap, a budget ceiling, a tight blast radius, a circuit breaker that trips when the loop repeats itself, a heartbeat, and a human-read gate. None of that is exotic; it’s the difference between an autonomous loop that’s an asset and one that’s a liability with good intentions. It’s the same instinct behind automation needing a panic button — give the leverage a way to stop before you give it the keys. If you’re running loops of your own and want to compare which brakes earned their place, my inbox is open.