Scheduling Recursive Reasoning in Looped Transformers

Boyuan Wang; Chengyao Yu; Jiaxi Ren; Hongxin Wei; Bingyi Jing; Yuxin Tao

cs.LGSep 29, 2026

Scheduling Recursive Reasoning in Looped Transformers

Authors: Boyuan Wang, Chengyao Yu, Jiaxi Ren, Hongxin Wei, Bingyi Jing, Yuxin Tao

Organizations: Southern University of Science and Technology · The Chinese University of Hong Kong, Shenzhen · Shenzhen Loop Area Institute

Abstract

Recurrent reasoning models have attracted growing attention for scaling test-time computation, typically by iteratively refining latent states with shared parameters. However, these models apply each learned update with a fixed unit scale, which can be conservative when updates make persistent progress and overly aggressive when they fluctuate, limiting the benefit of additional loops. To understand how the scale should vary along the trajectory, we first analyze the sensitivity of terminal loss to recurrent update scale. We show that its temporal average admits an exact decomposition into persistent-progress and centered-fluctuation contributions. Based on this, we introduce the Trajectory Adaptive Progress-Fluctuation Scheduler (TAPS), which tracks their balance across recurrent updates and adapts the step size online. Theoretically, we establish sufficient conditions under which TAPS reduces expected terminal loss and reaches a target quality in fewer recurrent loops. Empirically, we show that TAPS improves terminal accuracy across structured reasoning tasks without retraining. By further incorporating the progress-fluctuation principle into training, TAPS yields additional accuracy gains with up to 1.56 times wall-clock speedup at matched baseline accuracy. The broad applicability of TAPS is supported by its effectiveness across diverse recurrent architectures and inference strategies. Together, these results establish update scale as complementary control axis of recurrent inference alongside architecture and depth.

Figures & tables

Figure 1: Overview of TAPS. (a) Adaptive step sizes reshape recurrent trajectories by modulating update magnitude at inference time. (b) TAPS maintains more consistent update directions than unit-step by balancing progress and fluctuation across iterations. (c) This improved trajectory accelerates recurrent convergence, reaching comparable performance with fewer iterations.

Fixed schedules
Inference method	Sudoku ( $H=32$ )				Maze ( $H=16$ )
	Inference-only		Co-designed		Inference-only		Co-designed
	Accuracy	Speedup	Accuracy	Speedup	Accuracy	Speedup	Accuracy	Speedup
Standard ( $\eta=1.0$ )	89.67	1.000 $\times$	90.60	1.194 $\times$	78.80	1.000 $\times$	78.80	1.249 $\times$
Constant ( $\eta=0.8$ )	89.75	0.990 $\times$	91.25	1.275 $\times$	78.40	N/R	79.40	1.226 $\times$
Constant ( $\eta=1.2$ )	85.43	N/R	85.28	N/R	77.00	N/R	77.40	N/R

Table 1: Accuracy (%) and inference speed of fixed and adaptive step-size schedules on Sudoku (

H=32

) and Maze (

H=16

), under inference-only control and training–inference co-design. N/R indicates that the unit-step target is not reached within the loop budget.

Figure 2: Difficulty-adaptive inference on Sudoku-Extreme. Left: Exact accuracy across puzzle difficulty. Middle: executed transformer layers, with median and 25th–75th percentiles. Right: test-time scaling curves showing Exact accuracy as the effective-layer budget increases.

Figure 3: Controller update frequency. Accuracy–speedup trade-offs at $q\in\{1,2,4\}$ for inference-only (gray) and co-designed (purple) TAPS. Co-design improves the trade-off across refresh intervals.

Fixed schedules
Inference method	Inference-only					P/S co-design SFT
	Inner		Outer		$\boldsymbol{\Delta}_{\mathrm{I-O}}$	Inner		Outer		$\boldsymbol{\Delta}_{\mathrm{I-O}}$
	Accuracy	Speedup	Accuracy	Speedup	$\boldsymbol{\Delta}_{\mathrm{I-O}}$	Accuracy	Speedup	Accuracy	Speedup	$\boldsymbol{\Delta}_{\mathrm{I-O}}$
Standard ( $\eta=1.0$ )	89.67	1.000 $\times$	89.67	1.000 $\times$	$0.00$	90.60	1.194 $\times$	90.60	1.194 $\times$	$0.00$
Constant ( $\eta=0.8$ )	89.75	0.990 $\times$	89.57	N/R	$+0.17$	91.25	1.275 $\times$	90.89	1.234 $\times$	$+0.36$
Constant ( $\eta=1.2$ )	85.43	N/R	89.49	N/R	$-4.06$	85.28	N/R	90.38	1.145 $\times$	$-5.09$

Table 2: Accuracy (%) and inference speed of inner- and outer-loop step-size scheduling on Sudoku (

H=32

), before and after P/S co-design SFT.

\Delta_{\mathrm{I-O}}

is inner minus outer terminal accuracy, in percentage points; N/R indicates that the unit-step target is not reached within 32 loops.

Fixed schedules
Inference method	Ouro-1.4B					Huginn-0125
Inference method	MMLU	ARC-C	HellaSwag	GSM8K	Avg.	MMLU	ARC-C	HellaSwag	GSM8K	Avg.
Standard ( $\eta=1.0$ )	68.23	52.73	71.65	51.78	61.10	31.45	37.80	66.82	19.41	38.87
Constant ( $\eta=0.8$ )	59.75	50.17	68.02	33.89	52.96	30.97	37.54	66.54	19.79	38.71
Constant ( $\eta=1.2$ )	33.67	40.36	46.82	10.54	32.85	27.05	35.15	60.76	8.34	32.83
Adaptive controllers (ours)

Table 3: Accuracy (%) of fixed and adaptive step-size schedules under language-model recurrence, on Ouro-1.4B and Huginn-0125. Avg. is the mean over the four benchmarks.

Baselines
Inference method	CommonsenseQA		GPQA-Main		MMLU-Pro		Avg.
Inference method	Accuracy	$\bar{\eta}$	Accuracy	$\bar{\eta}$	Accuracy	$\bar{\eta}$	Accuracy	$\bar{\eta}$
Qwen3-4B-Instruct (Base)	78.87	–	34.15	–	57.30	–	56.77	–
Loop ( $\eta=1.0$ )	80.10	1.000	36.16	1.000	61.40	1.000	59.22	1.000
Adaptive controllers (ours)
TAPS (GD)	80.26	1.112	36.61	1.125	61.00	1.133	59.29	1.123

Table 4: Accuracy (%) and mean step-size multiplier

\bar{\eta}

of intermediate-layer recurrence in Qwen3-4B-Instruct (

K=3

\bar{\eta}

is the relaxation factor averaged over recurrent forward passes; Avg. is the mean over the three benchmarks.

Appendix figures & tables12 assets

Supplementary material from the paper’s appendix.

Appendix

Benchmark	Shots	Prompt format	Scoring
MMLU	0	standard	label log-likelihood
ARC-C / HellaSwag	0	standard	normalized label log-likelihood
GSM8K	0 (CoT)	Let’s think step by step	extracted exact match
CommonsenseQA	7	standard	label log-likelihood
GPQA-Main	0	standard	label log-likelihood
MMLU-Pro (1k)	5 (CoT)	Qwen chat template	regex-extracted exact match

Appendix

Table 5: Evaluation protocols for language-model and intermediate-layer recurrence experiments. All evaluations use lm-evaluation-harness ( Biderman et al., 2024 ) with bfloat16 weights and greedy decoding for generative tasks. Ouro and Huginn use automatic vLLM batching, whereas intermediate-layer recurrence experiments use batch size 1.

Figure 4: Training–inference co-design improves the stability and generalization of recurrent reasoning. Left: Training task loss, shown with raw observations and a 300-step moving average. Middle: Local standard deviation of the training loss over the same window; P/S co-design reduces late-stage variability by 10.3%. Right: Validation exact accuracy at matched checkpoints, where P/S co-design improves the best accuracy by 0.8 percentage points.

Figure 5: P/S co-design produces smoother inference-time step-size schedules. Each curve shows the mean multiplier of one TAPS controller over 100 Sudoku examples, smoothed with a nine-step centered moving average; shading denotes one standard deviation across examples. After co-design, the average multiplier changes only slightly, while the adjacent total variation decreases by 5.7%, indicating more temporally stable step-size adaptation.

Training hyperparameters
	Task-only SFT	P/S co-design SFT
Dataset	Sudoku-Extreme
Initialization	TRM checkpoint at step 65,100
Training budget	1,000 epochs / 2,600 optimizer steps
Global batch size	384
Learning rate	$1\times 10^{-5}$

Appendix

Table 6: Training recipe for task-only SFT and P/S co-design SFT on Sudoku-Extreme. The two runs share all listed settings except the inference controller and the balance penalty.

Inference method	Accuracy	Effective Updates			Compute Saved
Inference method	Exact	Mean	Median	Max	Compute Saved
Baseline
Base (unit step)	90.40	1152.0	1152	1152	–
FPRM	91.10	1497.0	284	25838	$-29.9$ %
TAPS adaptive exit (ours)
TAPS (GD)	90.10	317.6	180	1152	72.4%

Appendix

Table 7: Accuracy (%) and inference cost of adaptive-exit rules on 1,000 held-out Sudoku-Extreme examples. Effective Updates counts recurrent-layer applications per example, and Compute Saved is the reduction in mean updates relative to Base, where negative values indicate additional computation. Base and TAPS use a maximum of 32 outer loops; FPRM uses its official stopping rule.

Fixed schedules
Inference method	Inference-only					P/S co-design SFT
	Inner		Outer		$\boldsymbol{\Delta}_{\mathrm{I-O}}$	Inner		Outer		$\boldsymbol{\Delta}_{\mathrm{I-O}}$
	Accuracy	Speedup	Accuracy	Speedup	$\boldsymbol{\Delta}_{\mathrm{I-O}}$	Accuracy	Speedup	Accuracy	Speedup	$\boldsymbol{\Delta}_{\mathrm{I-O}}$
Standard ( $\eta=1.0$ )	78.80	1.000 $\times$	78.80	1.000 $\times$	$0.00$	78.80	1.249 $\times$	78.80	1.249 $\times$	$0.00$
Constant ( $\eta=0.8$ )	78.40	N/R	78.80	1.245 $\times$	$-0.40$	79.40	1.226 $\times$	79.50	1.245 $\times$	$-0.10$
Constant ( $\eta=1.2$ )	77.00	N/R	78.70	1.245 $\times$	$-1.70$	77.40	N/R	79.50	1.660 $\times$	$-2.10$

Appendix

Table 8: Accuracy (%) and inference speed of inner- and outer-loop step-size scheduling on Maze (

H=16

), before and after P/S co-design SFT.

\Delta_{\mathrm{I-O}}

is inner minus outer terminal accuracy, in percentage points; N/R indicates that the unit-step target is not reached within 16 loops.

Figure 6: Step-size trajectories across control granularities on Sudoku. The first three panels show inner-loop control with $q\in\{1,2,4\}$ , while the last shows outer-loop control; shading indicates variation across samples. Changing the refresh frequency alters the resulting schedule rather than merely reducing controller evaluations.

Table 15

Fixed schedule
Inference method	Noise on $\boldsymbol{z_{L}}$					Noise on $\boldsymbol{z_{H}}$
Inference method	$\boldsymbol{\sigma=0.2}$	$\boldsymbol{\sigma=0.4}$	$\boldsymbol{\sigma=0.6}$	$\boldsymbol{\sigma=0.8}$	$\boldsymbol{\sigma=1.0}$	$\boldsymbol{\sigma=0.2}$	$\boldsymbol{\sigma=0.4}$	$\boldsymbol{\sigma=0.6}$	$\boldsymbol{\sigma=0.8}$	$\boldsymbol{\sigma=1.0}$
Standard ( $\eta=1.0$ )	97.33	97.60	97.37	97.60	97.87	97.70	96.20	91.63	87.27	82.37
Adaptive controllers (ours)
GD	97.70	97.50	97.53	98.07	97.70	98.03	96.17	91.17	86.50	81.10
P/S-Sign	97.70	97.70	97.90	97.80	97.73	97.60	96.17	90.63	85.33	80.77

Appendix

Table 11: Accuracy (%) of fixed and adaptive step-size schedules under Gaussian perturbations to the recurrent latent states, on 1,000 held-out Sudoku-Extreme examples (

H=16

, 25 parallel rollouts). Noise with standard deviation

\sigma

is injected into either the low-level state

z_{L}

or the high-level state

z_{H}

, and each entry reports Best-Q accuracy over the 25 rollouts.

Fixed schedules
Inference method	Ouro-2.6B
Inference method	MMLU	ARC-C	HellaSwag	GSM8K	Avg.
Standard ( $\eta=1.0$ )	73.65	58.36	76.45	76.95	71.35
Constant ( $\eta=0.8$ )	66.16	52.82	71.85	36.54	56.84
Constant ( $\eta=1.2$ )	52.28	51.79	68.40	42.68	53.79
Adaptive controllers (ours)

Appendix

Table 12: Accuracy (%) of fixed and adaptive step-size schedules under language-model recurrence, on Ouro-2.6B. Avg. is the mean over the four benchmarks.

TAPS controller	CUDA latency (ms/example)			Speedup
TAPS controller	Original	+ Alg.	+ Alg. + Op.	Alg.	Op.	Overall
Adaptive controllers (ours)
TAPS (GD)	11.204	11.195	10.743	1.001 $\times$	1.042 $\times$	1.043 $\times$
TAPS (P/S-Sign)	11.219	11.029	10.768	1.017 $\times$	1.024 $\times$	1.042 $\times$
TAPS (Momentum)	11.236	11.207	10.745	1.003 $\times$	1.043 $\times$	1.046 $\times$
TAPS (RMSProp)	11.285	11.281	10.760	1.000 $\times$	1.048 $\times$	1.049 $\times$

Appendix

Table 13: Latency and speedup of algebraic and operator-level acceleration for TAPS on Sudoku (

H=16

). Latency is the cumulative CUDA time per example over 16 outer loops. Alg. reports the speedup from algebraic simplification relative to the original implementation, Op. the additional speedup from operator fusion relative to + Alg. , and Overall the combined speedup relative to the original implementation.

Figure 7: Fusing the TAPS controller update. The eager implementation executes each controller stage as a separate GPU kernel, whereas the fused operator keeps intermediate state on chip and completes the update through a single streaming path.

Explore similar work

Aug 25, 2026

Steering Recurrent Reasoners at Inference Time with Readout Feedback

Recurrent models, which repeatedly update latent states with shared computation blocks, have emerged as powerful architectures for solving complex reasoning tasks. Existing inference-time methods scale computation by running more steps or sampling more trajectories, but ignore information revealed within each trajectory. Here we show that recurrent models can be improved at inference time by using their own readout probabilities to steer latent dynamics without retraining. We introduce Readout Feedback (RoFB), a test-time intervention that converts intermediate predictions into token-wise pairwise coupling forces injected into the latent dynamics. Across three recurrent models (AKOrN, ItrSA++, TRM) on Sudoku and Maze, RoFB yields clear gains in four of six model-task pairs and a small gain in one. The four positive pairs achieve performance unattainable by merely running more steps or selecting from multiple trajectories, at comparable or lower computational cost. These results suggest that closed-loop steering of latent dynamics can serve as a complementary inference-time control mechanism for recurrent reasoning models.

Shunsuke Kamiya, Masanori Koyama, Seongcheol Jeong +5

Graduate School of Engineering, The University of Tokyo

Inference-Time Guidance Recurrent Neural Networks

Ask PDF

Sep 29, 2026

What Makes Recurrence Effective in Looped Language Models?

Looped language models (LoopLMs) increase computational depth through parameter sharing, offering a path to scale inference computation without adding parameters. However, it remains unclear when additional recurrence is beneficial and how architectural choices affect its effectiveness. Through controlled experiments, we systematically examine (1) when recurrence helps, (2) where it should be applied, and (3) how its conditioning affects performance. Our evaluation covers inference budgets below, within, and beyond the training horizon under knowledge and reasoning tasks. (1) We find that recurrence can improve reasoning beyond the training horizon while degrading knowledge performance, but harder reasoning instances do not consistently benefit more. (2) Performance also depends on how distinct layers and recurrent iterations are allocated, showing that effective depth alone is insufficient to predict behavior. Non-recurrent output layers improve robustness to under-unrolling, while the preferred placement of input and output layers varies with inference budget. (3) Finally, we find that conventional initial-state injection offers limited robustness to varying recurrence depth. We therefore propose history-state injection as an alternative, and show that channel-wise history-state injection combined with timestep conditioning offers a low-cost and more effective design, better preserving knowledge under extended unrolling while improving robustness across inference budgets. Overall, our results clarify when recurrent computation helps, where it fails, and offer practical guidelines for designing LoopLMs across variable inference budgets.

Xinlin Zhuang, Siyuan Wang, Imran Razzak +1

The Chinese University of Hong Kong · MBZUAI

Recursive Language Models Efficient Language Model Inference Recurrent Transformers Inference-Time Scaling

Ask PDF

Oct 8, 2026

Scaling to Tens of Thousands of Test-Time Iterations with Loop-Native Attention Residuals

In this paper, we argue that looped Transformers need their own residual connections to prevent performance degradation as the number of iterations grows. We observe that increasing loop iterations can reduce reasoning accuracy: noisy state updates overwrite correct intermediate deductions and even undo completed solutions. This leaves subsequent iterations to recover lost information from an already degraded representation: once an error arises in an earlier loop, often as a result of long-range propagation through the recurrence, later loops find it difficult to correct. In this paper, we introduce InfiLoop, a loop-native residual connection that learns which past computations to retain and how much to accept from each new update. InfiLoop combines content-based weighting with learned temporal decay to maintain a running summary of recurrent states. An exact streaming recurrence keeps its persistent aggregation memory constant as the loop count grows. The resulting adaptive update suppresses unreliable proposals and preserves useful intermediate states. Across extensive reasoning tasks, a 7M-parameter InfiLoop model outperforms existing recursive architectures, reaching 97.9% exact accuracy on Sudoku-Extreme, and 13.6% pass@2 on ARC-AGI-2. Notably, on Sudoku-Extreme, InfiLoop continues to improve with test-time looping beyond 20,000 effective steps, showing that added depth translates directly into stronger reasoning. Our code is available at https://github.com/pixeli99/InfiLoop.

Pengxiang Li, Dilxat Muhtar, Di He +3

The Hong Kong Polytechnic University · Independent Researcher · Shenzhen Institutes of Advanced Technology, Chinese Academy of Sciences +6

Recurrent Transformers Attention Residual Connections Neural Algorithmic Reasoning Efficient Language Model Reasoning Inference-Time Scaling

Ask PDF