// term 80 · Reasoning & Cognition
Recursive Reasoning
Multi-Pass Problem Solving
Applying the same reasoning process repeatedly at successive levels of a problem — decomposing, solving sub-problems, and composing results back upward. Recursive reasoning is how bounded cognitive steps conquer unbounded problem depth: the divide-and-conquer of thought.
// Mechanism
self-similar
The same decompose-solve-compose move applied at every level — one process, arbitrary depth.
// Power
depth from steps
Problems beyond any single pass yield to bounded steps applied recursively — complexity conquered by structure.
// Hazard
error cascade
Mistakes at depth propagate upward through composition — verification at each level is the discipline that contains them.
// full definition
What Recursive Reasoning actually is
Some problems are too deep for any single pass of reasoning — the analysis that needs analyses, the plan whose steps need plans. Recursive reasoning answers with self-similarity: apply one move — decompose the problem, solve the parts, compose the results — and where a part is itself too complex, apply the same move to it. Depth stops being a barrier and becomes a dimension the process traverses, level by level, until sub-problems are simple enough to solve directly.
The pattern is the deep structure beneath the named reasoning techniques. Chain of thought is recursion's flattest case — one level of decomposition into sequential steps. Tree of thoughts recurses through alternatives, exploring and pruning branches. Agentic planning recurses through goals: objectives into sub-goals into actions, each level planned by the same logic. Multi-agent orchestration distributes the recursion — an orchestrator decomposing for workers who decompose for themselves. One structural idea, many production costumes.
For LLMs, recursion solves a boundary problem: any single context window and reasoning pass is finite, but recursive structure lets bounded passes compose into unbounded depth. Each sub-problem gets a fresh, focused engagement — its own context, its own full attention — rather than competing for space in one overloaded pass. The orchestration layer carries the structure (what's been decomposed, what's solved, what composition awaits), letting the model do what it does well, repeatedly, in a scaffold that does what it can't.
Two disciplines keep recursion honest. Base-case judgment: knowing when a sub-problem is simple enough to solve directly — decompose too eagerly and the process wanders into infinite regress and budget burn; too lazily and complexity overwhelms passes meant to be simple. And composition verification: solved parts must assemble into a valid whole, with errors at depth checked before they propagate upward through every level above. Recursion multiplies reasoning power and error surface together; verification at each level is what keeps the multiplication favorable.
// how it works
Reasoning that calls itself
Recursive reasoning runs one playbook at every level — decompose, delegate downward, solve at the base, compose upward — until depth is exhausted.
Complexity Assessment
The problem is judged: solvable directly, or too deep for one pass? — the base-case decision that gates recursion.
Decomposition
The problem splits into sub-problems — smaller, more tractable, and collectively equivalent to the whole.
Recursive Descent
Each sub-problem re-enters the same process — decomposing further wherever depth demands.
Base-Case Solving
Simple-enough sub-problems solve directly — full attention applied to pieces sized for a single pass.
Composition
Solutions assemble back up the levels — parts integrated into wholes, level by level toward the original problem.
Level Verification
Each composition checks before ascending — errors caught at their level, not inherited by every level above.
// anatomy
The components teams must understand
01
Self-Similar Step
One move, every level
Decompose-solve-compose applied identically at each depth — the structural economy that makes recursion tractable.
02
Base Case
Where descent stops
The judgment that a sub-problem is directly solvable — recursion's brake, and its most consequential decision.
03
Decomposition Quality
The split's integrity
Sub-problems that genuinely partition the whole — bad splits solve the wrong problem at every level beneath them.
04
Orchestration Scaffold
Structure outside the model
The harness tracking what's decomposed, solved, and pending — recursion's bookkeeping, carried by the system.
05
Composition Logic
Parts into wholes
Assembly of sub-solutions upward — where partial correctness either integrates or quietly conflicts.
06
Depth Budget
Bounded descent
Caps on recursion depth and compute — the limit that converts elegant theory into terminating practice.
// strategic implications
What this changes for the business
01 · Capability
Depth becomes addressable
Problems too deep for single-pass AI — multi-layer analyses, nested plans, system-spanning investigations — yield to recursive structure. The use-case frontier moves: evaluate complex workflows against recursive architectures, not single-prompt attempts.
02 · Architecture
The scaffold carries the recursion
Models reason per pass; orchestration carries structure across passes — decomposition state, solved parts, pending composition. Recursive capability is system design as much as model capability; invest in the harness accordingly.
03 · Risk
Verify at every level
Recursion multiplies error surface with reasoning power — a flaw at depth propagates through every composition above it. Level-by-level verification and depth budgets are the disciplines that keep the multiplication favorable; recursion without them compounds mistakes elegantly.
// common misconceptions
What Recursive Reasoning is not
Myth
“Recursive reasoning is a model feature you enable.”
Reality
It's an architectural pattern — orchestration applying models recursively with structure carried by the harness. The capability is built around models, exploiting per-pass strength inside a scaffold that supplies the depth.
Myth
“Deeper decomposition is better analysis.”
Reality
Every level adds cost and error surface — past the problem's natural structure, decomposition is regress, not rigor. Base-case judgment, knowing when to just solve, is half the discipline.
Myth
“If the parts are right, the whole is right.”
Reality
Composition is its own failure point — locally correct parts conflict, double-count, and miss interactions. Assembly verification at each level is where recursive results earn their validity.
// from literacy to leverage
Know the term. Now build the strategy.
Vocabulary is the entry fee. Turning these primitives into pipeline, moats, and margin is the work. That's the conversation.