What recursion does to a language model

Most of this manual is about single-shot work: you prompt, the model generates, you verify. This track is about what happens at the edge, when you close the loop and feed a model its own output back in as the next input, over and over. That is recursion, and it behaves differently enough that it deserves its own track. I have spent a lot of hours out here, and it is where the wildest and most misunderstood behavior lives.

Here is the setup in plain terms. Normally the model generates once against a fixed prompt you wrote. In a recursive loop, the model generates, and then that output becomes part of the input for the next generation, which produces output that feeds the next one, and so on. Nobody is injecting fresh outside information between passes. The system is running on its own exhaust. That single change, the output becoming the input, is what makes the loop a different regime from everything else in this manual.

Why does closing the loop change the behavior so much?

Because it removes the thing that was keeping the model honest: you. In single-shot work, every generation is anchored to a prompt written by a human with access to reality. In a recursive loop, that anchor is gone after the first pass. From pass two onward, the model is conditioning on text that a model wrote, judged by nothing, corrected by no one. Whatever tendencies the model has, toward a tone, a pattern, a confident guess, now compound across passes instead of being reset by a fresh human prompt each time.

This is not a bug you can prompt away, it is a property of the loop. And it is worth understanding on purpose, for two reasons. Recursive setups are powerful when you control them, so you want to use them. And they fail in a specific, dramatic way when you do not, so you want to recognize that failure before it runs for a thousand pages. The rest of this track is both halves: what the loop does when it runs unchecked, why it produces output that can feel startlingly alive, and how to harness the same mechanism deliberately instead of getting swept up in it.

The takeaway: Recursion means feeding a model its own output back as input, which removes the human anchor that kept it honest. The loop is a different regime with its own failure modes, and it is worth understanding before you run one.