Looping Isn’t as Good (or as Bad) as We Thought
ML
LLM
scaling-laws
position-paper
Abstract
At matched compute, a looped block is worth roughly the square root of its cost in unique layers. This article argues that looping is better judged as one mechanism for serving many cost tiers from a single model, where its distinct strengths are depth on depth-bound tasks and a small weight footprint.
Keywords
looped language models, looped transformers, recurrent depth, test-time compute, scaling laws, KV cache, elastic deployment, latent reasoning
\[ \newcommand{\coloneq}{\mathrel{:=}} \]
NoteAs of October 2026
This position paper reflects the literature as of October 2026. Most of the sources are recent preprints, and several of the numbers come from single studies at modest scale.
Introduction
If I run the same block of layers four times, have I built a model four blocks deep? It certainly costs as much as one: four passes through the block require four times the arithmetic. But when the question is put to measurement, the answer is no. In a controlled scaling study (Schwethelm, Rueckert, and Kaissis 2026), a block looped four times behaves like a little under two unique blocks. Accounting for the other two is most of the story of looped language models, and it leads directly to a second question: matched against what? A looped model that equals a dense model twice its size has achieved something considerable if the two cost the same to run, and something ordinary if the looped model spent four times the compute to get there.
The position I defend here is that looping is best judged as a product capability. At matched FLOPs, looping loses to spending the same compute on unique parameters. What it provides is a different resource trade, exchanging FLOPs and KV-cache memory for weight memory and an elastic depth dial. Elasticity, meaning many service tiers served from one training run and selected by the customer, is a legitimate objective in its own right, and commercial APIs already sell it through reasoning-effort and thinking-budget settings (OpenAI n.d.; Anthropic n.d.). Judged as one mechanism for that objective, alongside reasoning length, nested width and depth, and routing, looping is not the cleanest on current evidence; its distinct advantages are depth on depth-bound tasks and very small weight footprints.
Looped Transformers
A looped, or recurrent-depth, transformer reuses one block of layers several times within a single forward pass. With \(x\) the token embeddings, \(f\) and \(g\) the layers applied once before and after the loop, and \(F_\theta\) the shared block, \[ \begin{aligned} h &= f(x), \\ z_k &= F_\theta(z_{k-1},\, h), \qquad k = 1, \dots, r, \qquad z_0 \sim \mathcal{N}(0, \sigma^2 I), \\ y &= g(z_r), \\[6pt] N &= N_{\text{once}} + N_{\text{rec}}, \qquad C \propto N_{\text{once}} + r\, N_{\text{rec}}, \qquad M_{\text{KV}} \propto L_{\text{once}} + r\, L_{\text{rec}}, \end{aligned} \tag{1}\] where \(N_{\text{once}}\) and \(N_{\text{rec}}\) count the parameters in \(f, g\) and in \(F_\theta\), \(C\) is compute per token, and \(M_{\text{KV}}\) is the KV cache per token, proportional to the number of executed layers. The last line states the trade: parameters are paid for once, while compute and cache are paid for \(r\) times. The input \(h\) is re-injected at every step and \(z_0\) drawn at random in Huginn (Geiping et al. 2025), every pass attends over the full context, and \(r\) can be fixed, sampled during training, or chosen at inference.
Looping is useful for computation that cannot be amortised into a fixed depth, that is, for problems whose inherently sequential work grows with the input. Fixed-depth transformers with log-precision arithmetic can be simulated by constant-depth threshold circuits (TC⁰), so if L ≠ P they cannot solve problems that require inherently sequential computation, however wide they are made (Merrill and Sabharwal 2022); a loop adds depth that grows with the iteration count.
What follows is a conjecture, not a proven characterisation, of how a loop that computes behaves. For an input \(h\), let \(z_k\) be the state after \(k\) applications of \(F_\theta(\cdot, h)\), \(z^\star(h)\) a point with \(F_\theta(z^\star(h), h) = z^\star(h)\), \(T(h)\) a neighbourhood of \(z^\star(h)\) on which \(F_\theta(\cdot, h)\) contracts, \(\tau(h)\) the first \(k\) with \(z_k \in T(h)\), and \(W(h)\) the number of dependent steps the task requires on input \(h\). The conjecture is that a loop that computes satisfies \[ \begin{aligned} \text{(i)}\quad & z_k \to z^\star(h) \ \text{ for every } z_0, \\ \text{(ii)}\quad & \tau(h) = \Theta\big(W(h)\big), \\ \text{(iii)}\quad & \rho\big(\partial_z F_\theta(z^\star(h), h)\big) < 1, \end{aligned} \tag{2}\] in which case it reaches accuracy \(\varepsilon\) after \(\tau(h) + O(\log 1/\varepsilon)\) steps: a computation phase whose length depends on the input, then a settling phase whose length does not. Convergence to \(z^\star(h)\) from every starting state is the echo state property (Manjunath and Jaeger 2013): the outcome depends on the input and not on \(z_0\). That the transient lasts \(\Theta(W(h))\) steps is certified by a ranking function (Floyd 1967), a map \(V(\cdot\,; h) \ge 0\) that vanishes on \(T(h)\), equals \(W(h)\) at \(z_0\) and falls by between \(c\) and \(C\) per step outside \(T(h)\), for constants \(0 < c \le C\). A spectral radius below one at \(z^\star(h)\) holds exactly when \(F_\theta(\cdot, h)\) contracts near \(z^\star(h)\) in some norm, not necessarily the Euclidean one, and guarantees that \(T(h)\) exists. A family of contractions with a common rate on a bounded state space converges from every start and is locally stable, but for unbounded \(W\) its transient cannot scale with the work, since \(\tau(h)\) is then bounded independently of \(h\).
No result establishes these conditions for trained models, and none of the analyses below tests them jointly, but each reports behaviour consistent with part of the conjecture (Anil et al. 2022; Viakhirev et al. 2026; T. Zhang et al. 2026; Kim 2026). Path independence predicts whether additional test-time iterations help. In small recurrent reasoners that extrapolate successfully, the Jacobians of the shared block are strongly non-normal, with largest singular value four to five times their spectral radius, so they are locally stable at the limit while amplifying transiently, and the computation takes place in that transient. On group word problems, trained loops advance a computation frontier by a fixed number of positions per loop, so that the transient grows linearly with input length, as it should when the work itself is proportional to length; and initialisation selects how compute scales. Nothing in training enforces such structure directly; where it appears, it does so under randomised loop counts, input re-injection, noise-initialised state and truncated backpropagation through the final iterations (Geiping et al. 2025), a recipe that makes test-time variation of depth possible and carries a cost that will reappear below.
Returns to Recurrence
Because a looped model has fewer parameters than the computation it performs, no single comparison controls for everything. At matched parameters, the looped model spends about \(r\) times the compute and wins, which answers what the best model at a fixed weight budget is. At matched FLOPs, it has fewer parameters and loses, which answers what the best use of a compute budget is. Matching both is impossible for a dense model, since Equation 1 forces \(r = 1\), but possible with mixture-of-experts models, where it asks whether weight reuse is a good inductive bias. Which comparison matters depends on whether compute or memory binds.
Schwethelm, Rueckert, and Kaissis (2026) measure the returns to recurrence, how many unique blocks a shared block applied \(r\) times is worth, with a scaling-law fit over 116 training runs at a fixed executed depth of 20 layers, with \(r \in \{1, 2, 4, 8\}\) and roughly a fifty-fold range of compute. They model the effective size of a looped model as \[ N_{\text{eff}} = N_{\text{once}} + r^{\varphi}\, N_{\text{rec}}, \tag{3}\] so that \(\varphi = 1\) would make a recurrence as good as a new layer and \(\varphi = 0\) would make it worthless. The fitted value is \(\varphi = 0.46\), with a 95% confidence interval of \([0.41, 0.53]\) (their Table 2). Figure 1 shows what this means: a block applied \(r\) times is worth about \(\sqrt{r}\) copies of itself while costing \(r\), so at \(r = 4\) it is worth about 1.9 blocks for the price of four.
Two results from the same study bound how far this number should be read. The exponent depends on the recipe: hyperconnections raise it to 0.65 and truncated backpropagation lowers it to 0.38 (Table 3), so \(\varphi\) describes how looped models are currently trained rather than a constant of the architecture. And the deficit is concentrated in knowledge: dense models are better on tasks such as TriviaQA at every budget, while reading comprehension and compositional tasks are roughly tied (Figure 11, Table 9). This agrees with the report for Ouro (Zhu et al. 2025) that looped and non-looped models store about the same knowledge per parameter, near 2 bits, and that looping improves its manipulation rather than its storage. The strongest result in looping’s favour comes from the fully matched regime: SMELT (Wang et al. 2026) matches per-token FLOPs, total parameters and KV cache between looped and non-looped mixture-of-experts models and finds that looping saves 6.8–18% of training FLOPs at equal quality, although the looped model is also narrower and deeper, so part of the gain may be a depth-versus-width effect.
If looping loses at matched compute, its case must rest on other costs. Equation 3 allows an estimate of the memory trade. Take the 20-executed-layer setting with \(r = 4\), with two layers before the loop, a four-layer block applied four times and two layers after: eight unique layers, twenty executed. Its effective depth is \(4 + 4^{0.46} \cdot 4 \approx 11.6\) layers, so a dense model of the same width and quality needs about 11.6 layers. The looped model holds about 31% fewer weights but, without cache sharing, about 73% more KV cache per token. Total memory is weights plus a cache that grows with context length and batch size, so which model is smaller depends on how many tokens are held (Figure 2).
With multi-head attention at this width, the saving disappears at about five thousand cached tokens; with grouped-query attention, which shrinks the cache eightfold, at about forty thousand. For short contexts and a single user on memory-bound hardware, then, looping saves memory, and at long contexts or large batches naive looping uses more memory as well as more compute. The cache overhead is an engineering problem rather than a fixed cost. Mixture-of-Recursions (Bae et al. 2025) caches only the tokens active at each recursion, and the Looped Prediction Transformer (Monea et al. 2026) lets later recursions read the first recursion’s cache plus a short local window, reporting a cache about 4.7 times smaller than a standard looped model’s at five recursions and 4K context, at 150M to 1B parameters. The clearest case where the trade pays is at small scale: MobileLLM (Liu et al. 2024) repeats each block immediately, so the shared weights stay in cache, and gains 0.7 and 0.8 points of accuracy at 125M and 350M parameters with no increase in size.
Latency depends on which design is meant. Ouro (Zhu et al. 2025), Huginn (Geiping et al. 2025), Parcae (Prairie et al. 2026), SMELT (Wang et al. 2026), Mixture-of-Recursions (Bae et al. 2025) and MobileLLM (Liu et al. 2024) all loop per token inside ordinary autoregressive decoding. Decoding at small batch sizes is memory-bound, limited by moving weights rather than by arithmetic (Yuan et al. 2024), so a model executing twenty layers per token decodes at roughly the speed of a twenty-layer model, whatever its parameter count; at batch size 1, a decoding step of a looped model with two, three and five recursions takes about 2.3, 3.4 and 5.7 times as long as a standard model’s (Monea et al. 2026, Appendix F). Two techniques recover much of this. Self-speculative decoding, which drafts from shallow recurrences and verifies in batches, speeds up autoregressive decoding of Ouro-2.6B and Huginn-3.5B by 2.4 and 3.5 times without changing their outputs (Ha and Kim 2026), and per-token adaptive depth, served by an engine that batches tokens at different depths, holds the latency overhead of a looped model to 1.34 times the non-looped baseline, against 2.35 times at fixed depth (You et al. 2026). Dense models admit analogous self-speculation through early exit (Elhoushi et al. 2024), so the comparison that matters, between a looped model and a dense model of equal quality under the same decoding technique, has not been made. Prefill for long prompts is compute-bound (Yuan et al. 2024), and its cost grows by roughly \(r\).
The large latency gains reported for looping come from a different design, in which chain-of-thought tokens are replaced by latent thought slots processed in parallel and refined by a loop. LLoCoT (García et al. 2026) provides the clearest measurement, and Figure 3 sets its gains against its costs.
Each pass takes about 30 ms in both methods; the reasoning phase is fast because it makes far fewer sequential passes, while end-to-end time falls by only about a quarter and compute and peak memory rise. LLoCoT’s accuracy of 63.6 compares with 63.2 for chain-of-thought fine-tuning and 62.7 for answer-only fine-tuning, so on these tasks chain-of-thought contributes little to begin with. LOTUS (Fan, Svete, and Lee 2026) shows the same division of labour on GSM8K at 3B parameters: 70.0% against 71.5% for explicit chain-of-thought, while a model trained with two loop iterations instead of six reaches only 14.6%. The loop supplies serial depth and the slots supply width, and width is inexpensive only when compute would otherwise be idle, as at batch size 1. Lower latency is therefore a property of latent workspaces that replace chain-of-thought, obtained at higher FLOPs, and not of looping in general.
Looping as a Mechanism for Elastic Deployment
Elasticity is an objective in its own right, distinct from raising the capability ceiling. A system whose top tier equals a dense model, and whose lower tiers each equal an independently trained smaller model, has added no capability; it has replaced several training runs with one, and lets a single deployment be sold at several prices, with the tier selected by the customer. Commercial APIs already sell this: OpenAI exposes a reasoning-effort setting (OpenAI n.d.), and Anthropic a thinking budget whose tokens are billed as output (Anthropic n.d.). The relevant question for looping is therefore whether it serves this objective better than the alternatives, and that comparison needs a measure. Let \(Q^\star(c)\) be the best quality attainable at inference cost \(c\) by a model trained for that cost alone, and \(Q_E(c)\) the quality of an elastic system’s tier at the same cost. The price of elasticity is \[ \Delta_E(c) = Q^\star(c) - Q_E(c), \qquad c \in [c_{\min}, c_{\max}], \tag{4}\] the quality given up at each tier over the range of costs the mechanism spans. A good mechanism keeps \(\Delta_E\) small over a wide range. The cost \(c\) may be measured in FLOPs, weight memory or latency, and the ranking of mechanisms can change with that choice.
Reasoning length is the mechanism these APIs expose. One model serves every tier, the reasoning remains readable, and budget control needs little machinery: forcing a model to stop or continue thinking moved s1-32B from 50% to 57% on AIME24 (Muennighoff et al. 2025). Its range extends only upwards from the base model, however, and every tier pays the full model’s weight footprint and per-token cost.
Nested width and depth supply the range below. MatFormer (Devvrit et al. 2023) trains nested feed-forward blocks jointly, and from one 850M-parameter model extracts submodels between 582M and 850M parameters, each better than an independently trained model of the same size; within that range the price of elasticity is negative. Flextron (Cai et al. 2024) converts a trained model into a nested elastic one using 7.63% of the original pretraining tokens, and outperforms several end-to-end trained variants. Nested depth, as early exit, can likewise be trained in once (Elhoushi et al. 2024). The demonstrated ranges are modest and the scales small, but a lower tier of a nested model is genuinely smaller, in weights, FLOPs, KV cache and latency, and Google’s Gemma 3n ships the MatFormer architecture for exactly this purpose (Google 2025). Routing between independently trained models (Chen, Zaharia, and Zou 2023; Ong et al. 2024) reports large cost reductions at matched quality, but every tier is a separate training run and a separate set of weights, which is the cost elastic models aim to avoid.
Looping’s price of elasticity can be measured directly, since adaptive halting does not prevent a compute-matched evaluation: the iteration count can be fixed or swept, and quality reported against inference FLOPs relative to a family of dense models. Measured this way, the price is positive. Marchenko et al. (2026) report both a parameter-matched and a compute-matched dense twin; their 1.4B looped model beats the former on all twelve benchmarks, comes within about a point of a 3.9B compute-matched model on mathematics and reading comprehension, and trails it by two to nine points on knowledge and commonsense. You et al. (2026) find that existing looped architectures added in post-training gain accuracy faster per unit of test-time compute but remain below the non-looped baseline at matched compute; their own method, which learns per token whether another iteration helps, is the exception, exceeding the baseline’s peak AIME accuracy by about 3.4 points at matched compute. The range is also bounded by training. Parcae (Prairie et al. 2026) finds that test-time gains saturate near the mean training depth, and in one Llama-1B-style configuration studied by Zhuang et al. (2026), loops past the training horizon raised a reasoning score from 28.5 to 31.5 while a knowledge score fell from 62.8 to 52.1. Elasticity must be trained in through randomised depth and truncated backpropagation, the latter being the change that lowered \(\varphi\) to 0.38 in Figure 1. Stopping rules need care: halting once successive outputs stop changing stops too early on synthetic multi-hop tasks, and requiring low output entropy as well corrects it (Kohli et al. 2026). Within the trained range the dial works, and Ouro’s learned exit gates achieve higher MMLU accuracy than static exits at every compute budget (Zhu et al. 2025).
Looping retains two advantages that the other mechanisms do not provide. The first is serial depth per token. Nesting can only remove computation and routing can only select among fixed-depth models; looping adds sequential steps without adding tokens, which is what depth-bound problems require. A 13.6M-parameter recursive model trained per task reaches 98.4% on Sudoku-Extreme and 84.7% on hard 30×30 mazes, where Qwen3-30B-A3B scores 0.0% and 0.2% (Shakhvalieva et al. 2026). Reasoning length also adds serial steps, but through a growing scratchpad, and theory indicates the two are complements: latent thought is more efficient for parallelisable computation, chain-of-thought retains an advantage through stochastic decoding (Xu and Sato 2025). A loop whose persistent state does not grow with the input, such as a fixed latent workspace, cannot decide P-complete problems that polynomial-length chain-of-thought can, if P is not contained in polylogarithmic space; loops that carry state at every position, as per-token looped language models do, fall outside this limit (H. Zhang 2026). The second advantage is footprint. Every tier of a looped model lives in the smallest set of weights, so where weights must fit in a small memory and contexts are short, the region to the left of the crossings in Figure 2, the most capable tier available is a looped one.
Conclusion
At matched compute, a looped block is worth roughly the square root of its cost in unique layers, and looping adds computation over a model’s knowledge rather than knowledge itself. It trades FLOPs, KV cache and prefill time for smaller weights and an elastic depth dial, a trade worth making where weight memory binds and contexts are short. Judged as a mechanism for elastic deployment, it is one candidate among four: on current evidence nested width and depth deliver the cleanest train-once, many-tiers result, reasoning length is the deployed way to raise effort above a base model, and routing reduces cost at matched quality at the price of one training run per tier. Looping’s distinct contributions are serial depth on depth-bound tasks and elasticity within a very small weight footprint. No study yet places these mechanisms on a common price-of-elasticity curve (Equation 4), and the ranking here is a judgement across separate studies at different scales; a direct comparison on that curve remains to be made.
References
Anil, Cem, Ashwini Pokle, Kaiqu Liang, Johannes Treutlein, Yuhuai Wu, Shaojie Bai, Zico Kolter, and Roger Grosse. 2022. “Path Independent Equilibrium Models Can Better Exploit Test-Time Computation.” https://arxiv.org/abs/2211.09961.
Anthropic. n.d. “Extended Thinking.” Accessed October 15, 2026. https://platform.claude.com/docs/en/build-with-claude/extended-thinking.
Bae, Sangmin, Yujin Kim, Reza Bayat, Sungnyun Kim, Jiyoun Ha, Tal Schuster, Adam Fisch, et al. 2025. “Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation.” https://arxiv.org/abs/2507.10524.
Cai, Ruisi, Saurav Muralidharan, Greg Heinrich, Hongxu Yin, Zhangyang Wang, Jan Kautz, and Pavlo Molchanov. 2024. “Flextron: Many-in-One Flexible Large Language Model.” https://arxiv.org/abs/2406.10260.
Chen, Lingjiao, Matei Zaharia, and James Zou. 2023. “FrugalGPT: How to Use Large Language Models While Reducing Cost and Improving Performance.” https://arxiv.org/abs/2305.05176.
Devvrit, Sneha Kudugunta, Aditya Kusupati, Tim Dettmers, Kaifeng Chen, Inderjit Dhillon, Yulia Tsvetkov, et al. 2023. “MatFormer: Nested Transformer for Elastic Inference.” https://arxiv.org/abs/2310.07707.
Elhoushi, Mostafa, Akshat Shrivastava, Diana Liskovich, Basil Hosmer, Bram Wasti, Liangzhen Lai, Anas Mahmoud, et al. 2024. “LayerSkip: Enabling Early Exit Inference and Self-Speculative Decoding.” https://arxiv.org/abs/2404.16710.
Fan, Ying, Anej Svete, and Kangwook Lee. 2026. “Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers.” https://arxiv.org/abs/2606.31779.
Floyd, Robert W. 1967. “Assigning Meanings to Programs.” In Mathematical Aspects of Computer Science, 19:19–32. Proceedings of Symposia in Applied Mathematics. American Mathematical Society. https://doi.org/10.1090/psapm/019/0235771.
García, Gerard Grau, Arnau Padrés Masdemont, Niccolò Grillo, Jordi Ros-Giralt, Arash Behboodi, and Victor Conchello Vendrell. 2026. “From Chain-of-Thought to Loops: Non-Autoregressive Latent Reasoning via Looped Transformers.” https://arxiv.org/abs/2610.11472.
Geiping, Jonas, Sean McLeish, Neel Jain, John Kirchenbauer, Siddharth Singh, Brian R. Bartoldson, Bhavya Kailkhura, Abhinav Bhatele, and Tom Goldstein. 2025. “Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach.” https://arxiv.org/abs/2502.05171.
Google. 2025. “Introducing Gemma 3n: The Developer Guide.” June 26, 2025. https://developers.googleblog.com/en/introducing-gemma-3n-developer-guide/.
Ha, Hyeongju, and Jae-Joon Kim. 2026. “WaveFront Decoding: Parallelized Self-Speculative Decoding for Looped Language Models.” https://arxiv.org/abs/2609.23033.
Kim, Gunn. 2026. “Dynamical Phase Selection Controls Compute Scaling in Looped Transformers.” https://arxiv.org/abs/2608.26556.
Kohli, Harsh, Srinivasan Parthasarathy, Huan Sun, and Yuekun Yao. 2026. “Loop, Think, , & Generalize Generalize: Implicit Reasoning in Recurrent-Depth Transformers.” https://arxiv.org/abs/2604.07822.
Liu, Zechun, Changsheng Zhao, Forrest Iandola, Chen Lai, Yuandong Tian, Igor Fedorov, Yunyang Xiong, et al. 2024. “MobileLLM: Optimizing Sub-Billion Parameter Language Models for on-Device Use Cases.” https://arxiv.org/abs/2402.14905.
Manjunath, Gandhi, and Herbert Jaeger. 2013. “Echo State Property Linked to an Input: Exploring a Fundamental Characteristic of Recurrent Neural Networks.” Neural Computation 25 (3): 671–96. https://doi.org/10.1162/NECO_a_00411.
Marchenko, Andrei, Viacheslav Bezrukov, Oleg Kashurin, Inessa Fedorova, Dmitry Bocharov, Yuliana Shakhvalieva, Maria Tikhonova, and Valerii Ternovskii. 2026. “Closing the Loop: Practical Training Recipes for Looped Language Models.” https://arxiv.org/abs/2610.00673.
Merrill, William, and Ashish Sabharwal. 2022. “The Parallelism Tradeoff: Limitations of Log-Precision Transformers.” https://arxiv.org/abs/2207.00729.
Monea, Giovanni, Keshav Ramji, Yousef El-Kurdi, Luis A. Lastras, Yoav Artzi, Nathan Godey, and Ramón Fernandez Astudillo. 2026. “The Surprising Effectiveness of Shared Memory in Looped Transformers.” https://arxiv.org/abs/2610.02383.
Muennighoff, Niklas, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, and Tatsunori Hashimoto. 2025. “S1: Simple Test-Time Scaling.” https://arxiv.org/abs/2501.19393.
Ong, Isaac, Amjad Almahairi, Vincent Wu, Wei-Lin Chiang, Tianhao Wu, Joseph E. Gonzalez, M Waleed Kadous, and Ion Stoica. 2024. “RouteLLM: Learning to Route LLMs with Preference Data.” https://arxiv.org/abs/2406.18665.
OpenAI. n.d. “Reasoning Models.” Accessed October 15, 2026. https://developers.openai.com/api/docs/guides/reasoning.
Prairie, Hayden, Zachary Novack, Taylor Berg-Kirkpatrick, and Daniel Y. Fu. 2026. “Parcae: Scaling Laws for Stable Looped Language Models.” https://arxiv.org/abs/2604.12946.
Schwethelm, Kristian, Daniel Rueckert, and Georgios Kaissis. 2026. “How Much Is One Recurrence Worth? Iso-Depth Scaling Laws for Looped Language Models.” https://arxiv.org/abs/2604.21106.
Shakhvalieva, Yuliana, Dmitrii Kharchev, Viacheslav Bezrukov, Inessa Fedorova, Dmitry Bocharov, Ivan Oseledets, and Valerii Ternovskii. 2026. “What Limits Recursive Reasoning Models: Optimization, Architecture and Test-Time Scaling.” https://arxiv.org/abs/2609.39967.
Viakhirev, Ivan, Kirill Borodin, Amirah Almutairi, Serguei Barannikov, Maxim Abramov, and Grach Mkrtchian. 2026. “Think Shallow, Solve Deep: Controlling Recurrent Dynamics for Reliable Test-Time Depth.” https://arxiv.org/abs/2608.18222.
Wang, Shaowen, Ge Zhang, Kairong Luo, Yuhao Wu, Shaofan Liu, Jiaheng Liu, Wenhao Huang, Shen Yan, and Jian Li. 2026. “SMELT: Scaling Laws for Compute-Matched MoE Looped Transformers.” https://arxiv.org/abs/2609.01343.
Xu, Kevin, and Issei Sato. 2025. “A Formal Comparison Between Chain of Thought and Latent Thought.” https://arxiv.org/abs/2509.25239.
You, Yichen, Tianyu Fu, Aosong Feng, Xingtai Lv, Xuefei Ning, Ning Ding, and Yu Wang. 2026. “Improving Test-Time Scaling with Adaptive Looped Transformers.” https://arxiv.org/abs/2609.35748.
Yuan, Zhihang, Yuzhang Shang, Yang Zhou, Zhen Dong, Zhe Zhou, Chenhao Xue, Bingzhe Wu, et al. 2024. “LLM Inference Unveiled: Survey and Roofline Model Insights.” https://arxiv.org/abs/2402.16363.
Zhang, Haozhou. 2026. “Chain-of-Thought and Compressed Looped Transformers: A Memory-Budget Separation.” https://arxiv.org/abs/2605.30757.
Zhang, Tong, Junhao Hu, Yun Peng, and Tao Xie. 2026. “When Does Recurrence Become an Algorithm? Convergence Selection in Weight-Tied Looped Transformers.” https://arxiv.org/abs/2607.20594.
Zhu, Rui-Jie, Zixuan Wang, Kai Hua, Tianyu Zhang, Ziniu Li, Haoran Que, Boyi Wei, et al. 2025. “Scaling Latent Reasoning via Looped Language Models.” https://arxiv.org/abs/2510.25741.
Zhuang, Xinlin, Siyuan Wang, Imran Razzak, and Weiyang Liu. 2026. “What Makes Recurrence Effective in Looped Language Models?” https://arxiv.org/abs/2609.36636.