“Recursive prompting” is having a moment, and most of what gets called recursive is a loop with a good memory. That is not a pedantic complaint. The two behave differently, fail differently, and cost differently, and knowing which one you are holding tells you when it will stop.
An earlier version of this post drew the line in the wrong place. It said a loop runs on fresh input and recursion feeds a prompt its own output. That is a real distinction, but it is not the difference between iteration and recursion — it is the difference between a loop that forgets and a loop that remembers. Both are loops. The correction is worth more than the original claim was.
Where the line actually falls
Iteration repeats a step, carrying state forward. x = f(x), again, until something says stop. Whether the input is fresh each time or is the previous answer changes what the loop does, not what it is.
Recursion is a procedure that calls itself on a smaller piece of the same problem, and has a base case that ends the descent. The test is not “does it use its own output.” The test is: does the work split into smaller versions of the same work, and is there a bottom?
Summarise a summary of a summary and you have a loop. Break a book into chapters, each chapter into sections, each section into paragraphs, summarise the paragraphs and build back up — that is recursion, and you cannot flatten it into a while-loop without inventing a stack to do it.
The two that are really loops
Refine. Produce something, critique it, rewrite it, critique the rewrite. Quality climbs for a few passes and then plateaus or drifts. The research calls this self-refine or reflexion, and those are the honest names for it. It is a loop, and it is genuinely useful.
Converge. Apply the same operation until the output stops changing — distilling a thing down to whatever survives the process. Also a loop. Its interesting property is the stopping condition: it ends when the text reaches a fixed point rather than when a counter runs out.
Both are worth using. Neither is recursion, and calling them recursion costs you the word you need for the thing that actually is.
The one that is really recursion
Decompose. Split a problem into parts. If a part is still too big, split it with the same procedure. Keep going until every leaf is small enough to solve outright, then assemble the answers back up the tree.
This is the shape that earns the name, and it is the one with real leverage, because the difficulty of the whole problem never has to fit in one context window. Only the leaves do. It is also how a system of agents spawning agents works: each one takes a piece, and any piece too large becomes a smaller set of the same job.
It brings recursion’s failure modes with it. A missing base case does not loop forever politely — it fans out, and each level multiplies the calls below it. Depth is the thing to bound, and bound it explicitly, because a model asked whether a sub-problem is “simple enough” will cheerfully say no forever.
Why the distinction pays
It tells you what to watch. A loop fails by plateauing: the fifth critique stops improving the draft, and the tenth starts making it worse. You cap the passes and take the best one.
Recursion fails by exploding. Breadth times depth is your bill, and it is paid before anyone reads the result. You bound depth, cap the branching factor, and require a leaf to be defined by something measurable rather than by the model’s opinion of its own difficulty.
Mistake one for the other and you will watch for the wrong failure. A plateau is annoying; a fan-out is expensive.
What to call things
Use iterative for a loop, with or without memory. Use self-refine or reflexion for the critique-and-rewrite version, since those are the established names. Save recursive for decomposition, where the work genuinely contains smaller copies of itself.
Everyone will keep calling all of it recursive. That is fine — language moves. But when you are deciding whether a job needs a capped loop or a bounded tree, the precise word is the one that tells you which failure is coming.
We build agentic systems that know when to stop — capped loops, bounded trees, and a limit on the bill before it arrives. That’s what we do at Rebel Studios.