Recurrent-depth reasoners aim to solve harder problems by iterating their update longer at test time, but additional iterations can improve, preserve, or degrade an answer. We show that a measurable property of the trained operator, its finite-time dynamical regime (estimated as settling, marginal, or drifting), indicates which of these occurs. We give a sufficient condition for depth-safety: once an operator's per-step displacement is small relative to the decoder margin, the decoded answer cannot change under further iterations. Empirically, on algorithmic tasks trained from 800 unaugmented examples per difficulty tier, settling operators do not degrade with added depth, and on some tasks convert it into higher accuracy on harder unseen instances (Sudoku, 0.19 to 0.34 past the training horizon). A single terminal fixed-point objective moves the regime and the depth behavior together: removing it induces drift and removes the gains, and adding it to a generic recurrence yields depth-safe extrapolation on carry propagation. We give four operational criteria for useful test-time depth, use them to catalogue failure modes, and, as a consistency check, apply the same measurements to Huginn-3.5B, which falls in the non-settling family.
Figures & tables
Figure 1: Two notions of “harder,” one task family. Left : larger graphs, competent on trained sizes (dashed), transfer nothing. Right : same-size, deeper instances, where settling models generalize and plateau.
Figure 2: Depth curves behind Table 1 : EM on the first unseen tier; one line = one run, colored by measured regime (boundary dotted, drift dash-dotted): settling runs rise and plateau, marginal rise and collapse or stay flat, drifting decay here or on deeper tiers (Sec. 5.4 ); which architecture settles differs per ladder.
Sudoku (hole fraction)
Reachability (path length)
Addition (carry length)
learn ↑
extrapolate ↑
overthink ↓
learn ↑
extrapolate ↑
overthink ↓
learn ↑
extrapolate ↑
overthink ↓
CoRe (full recipe)
1.00
0.19 → 0.34 ± 0.04
0
0.98
0.92 → 0.92 ± 0.10
0
0.99
0.13 → 0.17 ± 0.15
0.05
− structure
0.00
—
n/a
0.15 ± 0.02
—
n/a
= CoRe (no spatial structure on 1-D)
− extra input injection
0.29 ± 0.01
—
n/a
0.23
—
n/a
0.04 ± 0.02
—
n/a
− fixed-point objective
1.00
0.01 → 0.03 ± 0.01
0.04
1.00
0.97 → 0.97 ± 0.02
0.37 †
1.00
0.14 → 0.15 ± 0.02
0.81 †
generic recurrence
0.00
—
n/a
0.17 ± 0.01
—
n/a
1.00
0.11 → 0.12 ± 0.02
0.84 †
Table 1: Three questions, kept separate (mean ± sd): the primary ablations and all architectures (Appendix F , Table 3 for six further ablations, none switching mode). learn ↑ : in-distribution EM at best depth. extrapolate ↑ : first-unseen-tier EM at training depth → best over hc≤128 , selected per run on the evaluation set (R1 conversion). Bold = best value per column, ties included (max for learn/extrapolate, min for overthink; gated cells excluded). overthink ↓ : worst over tiers of best EM − EM@128 ( †= severe ≥0.2 loss, undesirable). EM <0.3 fails the competence gate: extrapolate/overthink are n/a (nothing to convert or lose). Reachability’s rounds stay below the training depth, so its middle column is generalization + safety, not conversion; “—” marks undefined or gated cells. Naming per Sec. 4 . CoRe , − fixed-point objective, and TRM-style cells carry n≈20 seeds, architecture rows n=10 , the remaining ablation rows n=3 .
Figure 3: One training term, three consequences (mean and seed range, first unseen tier). Removing the fixed-point objective destroys conversion (Sudoku, left) or safety (reachability, middle); adding only this term to the unchanged generic recurrence creates both on addition-carry (right): 0.12→0.88 , damage 0.91→0 .
Figure 4: Recurrence at scale, one prompt bank. Left : a latent depth knob (Huginn-3.5B) saturates without converting depth. Right three : token-budget knobs on open 7B reasoners (bold = illustrative family, n=40 /point); none shows the settling fate.
Table 2: Population and unit of analysis for each corpus. Counts differ by design; the depth-safety statistic and the regime figure below both use the original-ladder competent corpus (164 runs).
Figure 5: Regime → outcome on the 164 competent original-ladder runs (dot = run, bar = median; n per regime in axis labels). Left: depth conversion, EM(best) − EM at training depth on the first unseen tier. Right: overthinking damage, worst over tiers of EM(best) − EM@128. Settling runs show no overthinking tail; marginal and drifting runs do.
Figure 6: The Sudoku ablation landscape (all arms overlaid; colored = narrative-central operators, light blue = recipe variants, gray = others). (a) Lyapunov spectra: learners are anisotropic ; every failure family is flat. (b) Logit-lens rank of the correct answer (hardest training tier): CoRe crystallizes to ≈0 , generic bounces, the identity ablation is frozen. Depth curves for these arms are in the main text; the training-time formation view is in Sec. O .
Sudoku (hole fraction)
Reachability (path length)
Addition (carry length)
learn
extrapolate
overthink
learn
extrapolate
overthink
learn
extrapolate
overthink
CoRe (full recipe)
1.00
0.19 → 0.34 ± 0.04
0
0.98
0.92 → 0.92 ± 0.10
0
0.99
0.13 → 0.17 ± 0.15
0.05
− structure
0.00
0.00 → 0.00
0
0.15 ± 0.02
0.08 → 0.08 ± 0.03
0
= CoRe (no spatial structure on 1-D)
− extra input injection
0.29 ± 0.01
0.00 → 0.00
0
0.23
0.17 → 0.17
0
0.04 ± 0.02
0.00 → 0.00
0
− fixed-point objective
1.00
0.01 → 0.03 ± 0.01
0.04
1.00
0.97 → 0.97 ± 0.02
0.37
1.00
0.14 → 0.15 ± 0.02
0.81
− orthogonal init
1.00
0.19 → 0.34 ± 0.03
0
1.00
0.96 → 0.96 ± 0.01
0.05
1.00
0.18 → 0.32 ± 0.28
0
Appendix
Table 3: Full leave-one-out and architecture table (mean ± sd; architecture rows n=10 seeds, CoRe / − fixed-point/TRM-style n≈20 , other ablations and SE-RRM 3 ); column definitions as in main text Table 1. learn : in-distribution EM at best depth. extrapolate : first-unseen-tier EM at training depth → best over hc≤128 . overthink : worst over tiers of best EM − EM@128 (bold ≥0.2 ); “—” marks arm undefined or not run.
Signal
Diagnosis
Fix
σmax→1.0000 , solve steps flat
identity fixed point (“do nothing”)
extra input injection (recall)
Henrici →0 , σmax=ρ=1 , KY saturated
normal marginal wander (coverage learner)
structured step; fixed-point objective
λmax>0 , trajectory length exploding
drift; depth will hurt at test time
fixed-point objective
settles but EM =0 ; flat Lyapunov spectrum ( λ1−λ8<0.1 )
settled isotropically: converged to a non-algorithm
inductive bias (structure) / less augmentation, not more dynamics control
all eight estimated leading exponents <0 , rank curve monotone ↓ , EM rises with depth
learned recursion
none needed
seed-to-seed EM variance ≫
missing step-size adaptation / clipping
adaptive updates; clip
Appendix
Table 4: Signal → diagnosis → fix: what to monitor while training a recursive model, the pathology each pattern indicates, and the recipe component that treats it.
Figure 7: Hidden-feature rank across training checkpoints (Sudoku; colors as in the main text).
task
difficulty
train
eval
steps
Fixed-size ladders (depth axis; primary)
sudoku
hole fraction
0.2,0.35,0.5
0.2–0.7
8k
reach_pathlen
BFS depth
2,3
2,3,5,8,12
4k
addition_carry
carry-run len
2,4
2,4,8,16,28
4k
maze_pathlen
path length
6,12
6,12,24,48,80
6k
sort_disorder
displacement
2,4
2,4,8,16,24
4k
Appendix
Table 5: Per-task difficulty parameter, training/evaluation tiers (parameter values), and training-step budget. All other hyperparameters are shared (text above).
Standard Transformers have a fixed computational depth, limiting their ability to generalize to tasks that require variable-depth reasoning. The usual remedy, Chain-of-Thought (CoT), spends tokens to reason, inflating the key--value cache and making latency grow with the step count, so memory becomes the limiting cost when reasoning is served over large query batches. We study a depth-recurrent Transformer that decouples computational depth from parameter count by iterating a shared-weight block, so that each added reasoning step costs flat memory and linear latency, with no token generation. Three ingredients keep the recurrence stable for 20+ thinking steps: a silent thinking objective that supervises only the final output, LayerScale initialization, and an identity-biased gate that opens a gradient highway across steps. We characterize it on three compositional domains with decreasing structural bias: graph reachability (adjacency masking), nested boolean logic (relative positioning), and unstructured relational text (no positional cue). We find a computational frontier: accuracy climbs once the thinking-step count meets the task's complexity, reaching near-perfect performance on the two structured tasks and a lower plateau on unstructured text. How it climbs depends on the structural bias---abruptly from chance on the graph task, gradually on the other two. Depth recurrence extrapolates beyond the training range: it succeeds on the graph task where fixed-depth models barely extrapolate, and on the two sequence tasks comes within two points of fixed-depth Transformers that use 4--6.4× more parameters. On the graph task, whose adjacency mask makes propagation depth verifiable, intermediate per-step supervision---a standard recipe for deep iterative models---consistently harms this extrapolation. We release the code for reproducibility.
Hung-Hsuan Chen
Computer Science and Information Engineering National Central University Taoyuan, Taiwan
Test-time reasoning methods such as iterative refinement, decomposition, and repeated sampling are often evaluated in isolation, making their gains difficult to compare across models, benchmarks, and evaluation pipelines. We introduce a unified view of these methods as recursion operators over an agent's reasoning trace: GROW, which deepens a single reasoning path; PRUNE, which decomposes and recomposes the problem; and BRANCH, which samples alternative reasoning paths and selects among them. We evaluate all three operators against a single-pass chain-of-thought baseline under a shared harness with identical prompts, token budgets, and grading code. Across five benchmarks and three frontier models, comprising 14 model-benchmark settings, 49,327 graded items, and 151,876 model calls, BRANCH improves accuracy in all 14 settings by an average of 5.98 percentage points and is the best-performing operator in 12. In contrast, GROW yields a mean gain of 2.18 points and degrades performance in two settings, while PRUNE improves accuracy by 0.94 points on average. Analysis shows that BRANCH's advantage arises not only from exploring multiple reasoning paths, but also from recovering from truncation: its gains strongly correlate with the baseline rate of empty, budget-exhausted outputs (r = 0.72). These results weaken the hypothesis that different problems require routing among test-time reasoning operators; at this level of abstraction, repeated branching is consistently dominant. Finally, we show that unpaired evaluation and treating scoring-pipeline failures as model errors can materially change, and even reverse, comparative conclusions, motivating paired scoring as a standard protocol for test-time-compute evaluation.
People often tackle difficult problems by thinking more deeply or exploring more possibilities. Similarly, recursive reasoners, which reason by repeatedly applying a learned update rule to latent states, can also scale inference through more updates (depth) or additional trajectories generated by perturbing latent states (width). When people hit a dead end in their thinking, they may step back and approach the problem from a fresh angle. However, neither depth scaling nor perturbation-based width scaling of recursive reasoners can reliably achieve this: both may converge to incorrect attractors. To address this, we propose to explore diverse reasoning traces by applying different update maps to the same latent state, without any additional training. We realize this idea through Input-Conditioned Search (ICS), which searches over input conditions to induce alternative update maps from the pretrained reasoner. Across six reasoning tasks, ICS achieves the highest mean accuracy, while requiring up to two orders of magnitude fewer model FLOPs than the evaluated scaling baselines. Controlled experiments confirm that ICS can redirect trajectories from the same state. Our theoretical analysis and rigorous numerical verification also confirm that ICS can locally eliminate incorrect attracting fixed points. Together, these findings establish ICS as an effective axis for efficient test-time scaling and motivate further research on shaping recursive reasoning during training and at test time.
Haochen Shi, Tianwen Fu, Qianggang Ding +7
Mila – Quebec AI Institute · Université de Montréal · University of Southern California +2