20B Looping model (paper) matches or beats Qwen3 Coder 30B at 10% of pre-training tokens

Reddit r/LocalLLaMA Papers
looped-transformer mixture-of-experts pre-training open-source reasoning

Summary

Loopie models use a looped transformer architecture to match or exceed Qwen3 Coder 30B performance with only 10% of the pre-training tokens, demonstrating strong reasoning abilities and efficient scaling.

No content available
Original Article
View Cached Full Text

Cached at: 07/21/26, 04:45 PM 

# Loop the Loopies!
Source: [https://arxiv.org/html/2607.16051](https://arxiv.org/html/2607.16051)
\\authorTwo

Zitian Gao\\authorTwoYilong Chen\\authorTwoYihao Xiao\\authorTwoXinyu Yang\\authorThreeRan Tao\\authorThreeJoey Zhou\\authorThreeBryan Dai\\metadata\[\] See the full author contributions[here](https://arxiv.org/html/2607.16051#Sx1)\.

###### Abstract

We present the Loopie series, consisting of two Mixture\-of\-Experts \(MoE\) models: a 20B\-parameter model with 2B active parameters and a 6B\-parameter model with 0\.6B active parameters\. Looped Transformers have long faced a challenge: given anNN\-fold increase in pre\-training compute, increasing the parameter count by a factor ofNNusually outperforms looping a modelNNtimes\. Loopie addresses this challenge\. Extensive ablation studies, including comparisons with a vanilla 30B\-A3B model, show that Loopie substantially outperforms vanilla Transformer baselines trained with the same compute budget\. With a novel post\-training method, Loopie develops strong reasoning abilities and achieves frontier\-level reasoning performance\.

![[Uncaptioned image]](https://arxiv.org/html/2607.16051v2/x3.png)

###### Contents

1. [1Introduction](https://arxiv.org/html/2607.16051#S1)
2. [2The Loopie Series](https://arxiv.org/html/2607.16051#S2)1. [2\.1Architecture](https://arxiv.org/html/2607.16051#S2.SS1) 2. [2\.2Why Layer\-Loop?](https://arxiv.org/html/2607.16051#S2.SS2) 3. [2\.3Motivation](https://arxiv.org/html/2607.16051#S2.SS3) 4. [2\.4Loopie Recipe](https://arxiv.org/html/2607.16051#S2.SS4) 5. [2\.5Results](https://arxiv.org/html/2607.16051#S2.SS5) 6. [2\.6Scalability](https://arxiv.org/html/2607.16051#S2.SS6) 7. [2\.7Ablations](https://arxiv.org/html/2607.16051#S2.SS7) 8. [2\.8Why Only Two Loop Steps?](https://arxiv.org/html/2607.16051#S2.SS8)
3. [3Pre\-Training](https://arxiv.org/html/2607.16051#S3)1. [3\.1Evaluation](https://arxiv.org/html/2607.16051#S3.SS1) 2. [3\.2Initialization](https://arxiv.org/html/2607.16051#S3.SS2) 3. [3\.3Learning Schedule](https://arxiv.org/html/2607.16051#S3.SS3) 4. [3\.4Stage 1: Multi\-Epoch High\-Quality Pre\-Training](https://arxiv.org/html/2607.16051#S3.SS4) 5. [3\.5Stage 2: High\-Quality Annealing](https://arxiv.org/html/2607.16051#S3.SS5)
4. [4Post\-Training](https://arxiv.org/html/2607.16051#S4)1. [4\.1Supervised Pre\-Training](https://arxiv.org/html/2607.16051#S4.SS1) 2. [4\.2Reinforcement Learning](https://arxiv.org/html/2607.16051#S4.SS2) 3. [4\.3Results](https://arxiv.org/html/2607.16051#S4.SS3)
5. [5Related Work](https://arxiv.org/html/2607.16051#S5)1. [5\.1Looped Transformers](https://arxiv.org/html/2607.16051#S5.SS1) 2. [5\.2Inductive Biases](https://arxiv.org/html/2607.16051#S5.SS2) 3. [5\.3Theory, Mechanisms, and Scaling](https://arxiv.org/html/2607.16051#S5.SS3) 4. [5\.4Architectures, Training Objectives, and Inference](https://arxiv.org/html/2607.16051#S5.SS4) 5. [5\.5In\-Context, Algorithmic, and Compositional Generalization](https://arxiv.org/html/2607.16051#S5.SS5) 6. [5\.6Abstract Reasoning](https://arxiv.org/html/2607.16051#S5.SS6)
6. [6Future Work](https://arxiv.org/html/2607.16051#S6)
7. [7Conclusion](https://arxiv.org/html/2607.16051#S7)
8. [8Acknowledgments](https://arxiv.org/html/2607.16051#S8)
9. [References](https://arxiv.org/html/2607.16051#bib)
10. [A Architecture Details](https://arxiv.org/html/2607.16051#Ax1)
11. [B Pre\-training Details](https://arxiv.org/html/2607.16051#Ax2)
12. [C Scaling Ladder Details](https://arxiv.org/html/2607.16051#Ax3)
13. [D Supervised Pre\-training Details](https://arxiv.org/html/2607.16051#Ax4)

## 1Introduction

Looped Transformers, first introduced as Universal Transformers\(dehghani2018universal\), have recently re\-emerged as a compelling alternative to conventional depth scaling\. Rather than stacking distinct layers, they repeatedly apply the same model across recurrent steps, closely connecting this approach to parameter sharing in Transformers\(lan2019albert;dehghani2018universal\)\. This recurrent approach has shown strong empirical performance across a wide range of domains, including language modeling, algorithmic learning, and abstract reasoning\(gao2025universal;yang2023looped;jolicoeurmartineau2025trm;wang2025hierarchical;dehghani2018universal;saunshi2025latentthoughts;bay2025mixture;geiping2025scalinglatent;zhu2025scalinglatent;frey2026adaptive;huang2026equilibrium\)\.

A growing body of work suggests that recurrent computation is especially well suited to complex problems\. Looped Transformers can outperform vanilla Transformers on in\-context learning and data\-fitting tasks, and they can implement multi\-step gradient descent in context with far fewer parameters\(yang2023looped;fan2024looped;giannou2023looped;gatmiry2024can;gatmiry2024role;chen2025bypassing\)\. Studies of looped Transformers have also shown that recurrent computation allows shallow parameterizations to approach the performance of deeper untied models on reasoning tasks\(saunshi2025latentthoughts;jeddi2026loopformer;geiping2025scalinglatent;zhu2025scalinglatent\)\. These advantages are particularly visible on abstract reasoning tasks such as ARC\-AGI, Sudoku, and Maze, where results from recent recurrent models suggest that recurrence provides a powerful inductive bias for compositional generalization, rule discovery, and inductive reasoning\(wang2025hierarchical;jolicoeurmartineau2025trm;gao2025universal\)\.

Recent work has begun scaling looped Transformers to billion\-parameter language models\. Ouro models scale to 1\.4B and 2\.6B parameters with four recurrent steps, reporting strong parameter efficiency relative to larger dense baselines\(zhu2025scalinglatent\)\. Huginn scales to 3\.5B parameters and uses 32 recurrent steps to trade parameters for latent computation\(geiping2025scalinglatent\)\. Other systems further study adaptive recurrence, efficient reasoning, memory–compute trade\-offs, and scaling laws for stable looped language models\(bay2025mixture;jeddi2026loopformer;frey2026adaptive;prairie2026parcae\)\. However, these gains expose a fundamental compute\-accounting issue:looping a modelNNtimes during pre\-training also multiplies pre\-training compute byNN\. Thus, looped Transformers should be compared not only against vanilla Transformers with the same parameter count but also against non\-looped models trained under the same pre\-training compute budget\.This view is consistent with language\-model scaling and compute\-optimal training analyses, which evaluate quality as a function of parameters, data, and total training FLOPs rather than parameter count alone\(kaplan2020scaling;hoffmann2022training;prairie2026parcae\)\. For example, Ouro\-2\.6B with 4 loops should be compared against a baseline model with a parameter count close to 2\.6B × 4 = 10\.4B; likewise, after accounting for pre\-training compute, Huginn\-3\.5B with 32 loops should be compared against a much larger 112B\-parameter baseline model\. This motivates our central question:

*Can looped Transformers match or exceed vanilla Transformers under the same pre\-training compute budget?*

We answer this question with theLoopie Series: two looped MoE LLMs, Loopie\-20B\-A2B and Loopie\-6B\-A0\.6B, each trained with two loop steps\. Our key idea is theLoopie Recipe, a compute\-matched scaling recipe that addresses the main concern for recurrent\-depth scaling: under a fixed pre\-training compute budget, vanilla parameter scaling can otherwise dominate looping\(hoffmann2022training;prairie2026parcae\)\. With a novel post\-training method, Loopie develops strong reasoning abilities and achieves frontier\-level reasoning performance\.

Our contributions are threefold:

- •Compute\-matched scaling\.We introduce the Loopie Recipe to address the fixed\-compute challenge for looped Transformers and validate it through extensive ablations\.
- •Scalable looped MoE models\.We demonstrate that looped computation scales to large MoE language models by training Loopie\-20B\-A2B and Loopie\-6B\-A0\.6B\.
- •Large\-scale post\-training\.We scale Loopie through large\-scale post\-training, including a novel supervised pre\-training stage, it yields strong reasoning abilities\.

layer 1Attention MoE layer 2Attention MoE layer 3Attention MoE layerNNAttention MoE loopN\\times\\,NloopN\\times\\,NloopN\\times\\,NloopN\\times\\,NLayer\-loop

layer 1Attention MoE layer 2Attention MoE layer 3Attention MoE layerNNAttention MoE Model\-looploopN\\times\\,N

Figure 1:Illustration of the contrast betweenlayer\-loopandmodel\-loop\. The top panel shows layer\-loop, the loop schedule adopted by Loopie, in which each Attention/MoE layer is applied recurrently before passing its output to the next layer\. We demonstrate that this schedule achieves better performance on MoE backbones while also training more efficiently\. The bottom panel shows the traditional whole\-model recurrence pattern, which we call model\-loop, where the entire layer stack is traversed and then repeated\. This pattern is used by prior looped models such as Ouro and Huginn\(zhu2025scalinglatent;geiping2025scalinglatent\)\.
## 2The Loopie Series

This section presents the Loopie Series, from its architecture to the evidence for its scalability\. We begin by defining Loopie’s layer\-loop recurrence pattern and contrasting it with the classic model\-loop pattern used in prior looped language models\. We then motivate the design under a fixed pre\-training compute budget, where models that use recurrent depth must be compared against vanilla Transformers that spend the same compute on ordinary non\-recurrent capacity\. Building on this motivation, we introduce the Loopie Recipe, a compute\-matched scaling recipe for choosing stored width, stored depth, and recurrent depth\. We next present the main compute\-matched results, examine whether the advantage persists across model scales, and isolate the contribution of the layer\-loop pattern through ablations\. Finally, we discuss why Loopie uses only two recurrent steps\.

### 2\.1Architecture

Loopie largely follows the Qwen3\-MoE architecture\. In particular, its backbone is a decoder\-only Mixture\-of\-Experts Transformer, and its attention mechanism, sparsity pattern, and other architectural details remain the same as those of the Qwen3\-MoE family\. Detailed architectural specifications are provided in Appendix[A Architecture Details](https://arxiv.org/html/2607.16051#Ax1)\. The key architectural difference lies in how recurrent computation is applied\. Instead of simply repeating the entire model multiple times, Loopie adopts a different recurrence pattern that we calllayer\-loop\.

Prior looped language models, such as Ouro and Huginn\(zhu2025scalinglatent;geiping2025scalinglatent\), mainly use what we callmodel\-loop\. In model\-loop recurrence, the entire Transformer stack is unrolled recurrently: for a model with three layers and two loop steps, the computation order is

Layer 1Layer 2Layer 3Layer 1Layer 2Layer 3\.\\text\{Layer 1\}\\rightarrow\\text\{Layer 2\}\\rightarrow\\text\{Layer 3\}\\rightarrow\\text\{Layer 1\}\\rightarrow\\text\{Layer 2\}\\rightarrow\\text\{Layer 3\}\.By contrast, Loopie useslayer\-loop, in which each layer is applied recurrently before the computation moves to the next layer\. For the same three\-layer, two\-step example, the computation order becomes

Layer 1Layer 1Layer 2Layer 2Layer 3Layer 3\.\\text\{Layer 1\}\\rightarrow\\text\{Layer 1\}\\rightarrow\\text\{Layer 2\}\\rightarrow\\text\{Layer 2\}\\rightarrow\\text\{Layer 3\}\\rightarrow\\text\{Layer 3\}\.That is, each block performs local iteration on the hidden states and only then passes the resulting recurrent representation to the next layer\. Figure[1](https://arxiv.org/html/2607.16051#S1.F1)illustrates the difference\.

### 2\.2Why Layer\-Loop?

Layer\-loop is not merely a different ordering of recurrent computation; it changes where iterative refinement happens inside the model and therefore affects scaling behavior, execution efficiency, and the nature of parameter sharing across effective depth\. We adopt layer\-loop because it offers three advantages that are especially important for large\-scale pre\-training\.

#### Better empirical scaling\.

Layer\-loop achieves better performance than model\-loop in our pre\-training experiments\. As shown in Figure[2](https://arxiv.org/html/2607.16051#S2.F2), layer\-loop initially trails model\-loop slightly on downstream benchmarks\. However, it overtakes model\-loop after approximately1\.21\.2trillion training tokens and improves more rapidly thereafter\. The early advantage of model\-loop therefore does not persist as the training budget increases\.

![Refer to caption](https://arxiv.org/html/2607.16051v2/x4.png)Figure 2:Comparison of the average downstream benchmark scores between the layer\-loop and model\-loop variants of Loopie\-6B\-A0\.6B\. Although layer\-loop lags behind model\-loop early in training, it surpasses model\-loop later\.
#### Infrastructure\-friendly execution\.

Although layer\-loop and model\-loop have the same nominal number of layer applications and theoretical FLOPs, layer\-loop provides better execution locality\. Repeated applications of the same layer are adjacent in both the forward and backward computation graphs, which shortens the reuse distance for parameters and gradient contributions and simplifies activation checkpointing and gradient accumulation, especially under parameter sharding or offloading\. This locality is particularly beneficial for pipeline parallelism because all recurrent applications of a layer remain within the same pipeline stage before activations are transferred onward\. In contrast, model\-loop requires each microbatch to traverse the entire pipeline repeatedly and routes the output of the final stage back to the first stage at each loop boundary, introducing cyclic dependencies that may complicate scheduling, increase communication overhead and the number of pipeline bubbles, and reduce device utilization\.

#### Natural parameter\-sharing pattern\.

For example, consider a 48\-layer model such as Qwen3\-30B\-A3B with two model\-loop steps\. The third physical layer is applied at effective depths33and48\+3=5148\+3=51\. These two invocations occur after markedly different amounts of preceding computation and therefore receive hidden states at widely separated effective depths\. Prior analyses suggest that Transformer representations are organized nonuniformly across depth: lower and final layers can differ substantially from the comparatively homogeneous middle layers, while different linguistic abstractions tend to become most accessible at different stages of the network\(sun2025transformer;tenney2019bert;jawahar2019bert\)\. These observations do not directly establish gradient conflict, but they suggest that hidden states at widely separated effective depths need not place identical functional demands on a shared transformation\. Thus, model\-loop asks a single parameter set to accommodate potentially heterogeneous depth\-dependent roles\. In contrast, layer\-loop reuses a layer at adjacent effective depths, resulting in a more local and potentially more coherent parameter\-sharing pattern\.

### 2\.3Motivation

Despite their conceptual appeal, looped Transformers have historically been studied in settings that do not fully reflect the constraints of modern large\-scale language model pre\-training\. In particular, much of the prior work has focused on dense, weight\-shared, or recurrent Transformer variants and has evaluated recurrence primarily as a mechanism for improving parameter efficiency\(zhu2025scalinglatent;geiping2025scalinglatent\)\. This leaves two important issues underexplored\.

First, modern frontier language models increasingly rely on Mixture\-of\-Experts architectures, as exemplified by the recent Qwen3, Kimi K2\.5, GLM\-5, DeepSeek\-V4, and MiniMax\-M2 model families\(qwen3;kimi2026kimi25;glm5team2026glm5;deepseekai2026deepseekv4;minimax2026m2\)\. MoE models expand total model capacity while keeping the number of active parameters per token relatively small, making them substantially more favorable than dense models under both training and inference compute constraints\(shazeer2017outrageously;fedus2022switch;du2022glam;abnar2025parameters\)\. A practical looped architecture should therefore be compatible with MoE scaling rather than be restricted to dense backbones, because such a restriction would limit its ability to scale to larger model sizes\.

Second, pre\-training compute is often the dominant constraint in large\-model training\. It determines how large a model can be, how many tokens it can see, and how many experimental variants can be trained\(kaplan2020scaling;hoffmann2022training\)\. This creates a key difficulty for looped Transformers: recurrent computation is not free\. If a model is loopedNNtimes during pre\-training, its training compute is also multiplied by approximatelyNN\. Therefore, a looped model should not merely outperform a vanilla Transformer with the same stored parameter count\. To justify recurrence as a scaling strategy, it must compete with vanilla Transformers trained under the same pre\-training compute budget\.

This requirement is challenging\. Prior work suggests that, under fixed\-FLOP comparisons, a looped model can have less non\-recurrent capacity than a standard Transformer baseline\(csordas2024moeut;frey2026dualpath\)\. This is consistent with the conventional view that recurrence mainly improves parameter efficiency but not necessarily compute efficiency\(lan2019albert;takase2023lessons\)\. As a result, prior looped Transformers have not yet provided a clear path toward flagship models at the trillion\-parameter scale with frontier\-level performance\.

Loopie is designed to address this gap\. Our central observation is that recurrence becomes competitive under a fixed compute budget only when it is paired with an appropriate recurrence\-width\-depth trade\-off\. We formalize this principle as theLoopie Recipe: rather than treating loops as a direct substitute for additional parameters, one should jointly choose stored width, stored depth, and recurrent depth so that the resulting model maximizes performance under a fixed pre\-training compute budget\. This changes the role of recurrence from a parameter\-saving device into a compute\-matched scaling mechanism\.

### 2\.4Loopie Recipe

We now describe the empirical, hardware\-aware scaling procedure used to instantiate Loopie\-20B\-A2B\. Starting from a strong non\-recurrent MoE reference, theLoopie Recipecomprises three steps:

\(i\) constructing a recurrent seed model by halving the number of stored layers;\(ii\) executing each stored layer twice usinglayer\-loop; and\(iii\) using the resulting memory headroom to double the per\-device microbatch size, then reinvesting the measured training efficiency gain into additional model capacity while keeping the optimizer\-step time approximately matched to the reference model\.

In this work, we match models by realized pre\-training cost rather than by exact theoretical FLOPs\. For every comparison, we fix the hardware allocation, sequence length, number of tokens per optimizer step, activation\-checkpointing policy, optimizer, and training data\. Architectures may use different per\-device microbatch sizes according to their measured memory footprints\. When the microbatch size is increased, the number of gradient\-accumulation steps is reduced proportionally so that the number of tokens per optimizer step remains unchanged\.

We select the Loopie configuration whose measured end\-to\-end optimizer\-step time most closely matches the non\-recurrent reference\. Since both models use the same token budget and number of optimizer updates, this also approximately matches total wall\-clock training cost\.

The models are not matched by their theoretical FLOP counts\. Loopie performs more nominal computation per token, but the additional work is offset by the higher realized efficiency\. We refer to this operationally as a compute\-matched comparison\. Analytical FLOP and memory models are used only to construct and interpret candidate configurations\. The final architecture is selected using measured end\-to\-end training time in Megatron\-LM\(megatron\-lm\)\.

The measured efficiency gain comes solely from the reduced stored depth, which lowers activation memory and enables us to double the per\-device microbatch size while halving the number of gradient\-accumulation steps\.

#### Activation memory and microbatch efficiency\.

Under the checkpointing implementation used in our experiments, all recurrent applications of a stored layer are enclosed in the same checkpointed unit\. Consequently, the dominant activation memory term scales with stored depth rather than executed depth\. The activation memoryMactM\_\{\\mathrm\{act\}\}during training scales as\(MLSYS2023\_80083951;3433701\.3433727\)

Mact​s​b​D​L,M\_\{\\mathrm\{act\}\}\\propto s\\,bDL,whereDDis the hidden dimension,LLis the number of stored layers,bbis the per\-device microbatch size, andssis the sequence length\. The recurrent applications increase the amount of executed computation through the loop countRRbut do not introduceRRindependently stored sets of layer\-boundary activations under this checkpointing scheme\.

For a fixed global batch sizeBB, with per\-device microbatch sizebbandgggradient\-accumulation steps, we have

ReducingD​LDLcreates memory headroom that can be used to increasebb\. Because the number of gradient\-accumulation stepsggis reduced proportionally, the global batch size remains fixed:

b1=2​b0,g1=g02\.b\_\{1\}=2b\_\{0\},\\qquad g\_\{1\}=\\frac\{g\_\{0\}\}\{2\}\.The larger microbatch exposes more parallel work to each kernel and reduces the number of gradient\-accumulation micro\-steps required for each optimizer update\.

For a fixed architecture, the corresponding microbatch efficiency gain is measured directly as

Smb=tstep​\(D,L,R;b,g\)tstep​\(D,L,R;2​b,g/2\)\.S\_\{\\mathrm\{mb\}\}=\\frac\{t\_\{\\mathrm\{step\}\}\(D,L,R;b,g\)\}\{t\_\{\\mathrm\{step\}\}\(D,L,R;2b,g/2\)\}\.This measured quantity is the efficiency factor used by the Loopie Recipe\.

We use a Qwen3\-like 30B\-A3B MoE Transformer\(qwen3\)as the non\-recurrent reference, with

D0=2048,L0=48,R0=1\.D\_\{0\}=2048,\\qquad L\_\{0\}=48,\\qquad R\_\{0\}=1\.The first step is to construct a recurrent seed model by halving the number of stored layers and settingR=2R=2:

D=2048,L=24,R=2\.D=2048,\\qquad L=24,\\qquad R=2\.The leading\-order pre\-training compute\(hoffmann2022training\)scales as

C​\(D,L,R\)​L​D2​R\.C\(D,L,R\)\\propto LD^\{2\}R\.At a fixed width, this transformation preserves the number of Transformer block executions:

L​R=242=48=L0​R0,LR=24\\cdot 2=48=L\_\{0\}R\_\{0\},and therefore preserves the leading\-order Transformer block compute proxy:

L​R​D2=24220482=4820482\.LRD^\{2\}=24\\cdot 2\\cdot 2048^\{2\}=48\\cdot 2048^\{2\}\.
At the same per\-device microbatch size, the dominant activation memory term is reduced by half:

D​LD0​L0=204824204848=0\.5\.\\frac\{DL\}\{D\_\{0\}L\_\{0\}\}=\\frac\{2048\\cdot 24\}\{2048\\cdot 48\}=0\.5\.The recurrent seed model therefore performs approximately the same leading\-order Transformer block work as the reference while requiring substantially less memory for stored activations\(megatron\-lm;3433701\.3433727\)\.

The second step is to spend the resulting microbatch efficiency on additional model capacity\. To satisfy architectural and hardware alignment constraints, we restrict the candidate hidden sizes to multiples of 128\. We sweep feasible\(D,L\)\(D,L\)configurations around the recurrent seed model and retain candidates that support a microbatch size twice that of the reference\.

Table[1](https://arxiv.org/html/2607.16051#S2.T1)lists the candidate configurations\. We report the normalized leading\-order compute proxy:

Cwidehat=L​R​D24820482,\\widehat\{C\}=\\frac\{LRD^\{2\}\}\{48\\cdot 2048^\{2\}\},and the activation memory proxy at the reference microbatch size,

Mwidehatact=D​L482048\.\\widehat\{M\}\_\{\\mathrm\{act\}\}=\\frac\{DL\}\{48\\cdot 2048\}\.These quantities are used to describe the candidates, not to predict their final optimizer\-step times\.

Table 1:Candidate configurations generated from the Qwen3\-like 30B\-A3B reference\.Cwidehat\\widehat\{C\}is the normalized leading\-order Transformer block work proxy, andMwidehatact\\widehat\{M\}\_\{\\mathrm\{act\}\}is the normalized activation memory proxy at a fixed per\-device microbatch size\. Final compute matching is based on measured optimizer\-step wall\-clock time\.ConfigurationDDLLRRCwidehat\\widehat\{C\}Mwidehatact\\widehat\{M\}\_\{\\mathrm\{act\}\}Qwen3 30B\-A3B20484811\.001\.00\\times1\.001\.00\\timesSeed Loopie20482421\.001\.00\\times0\.500\.50\\timesLoopie candidate 121762521\.181\.18\\times0\.550\.55\\timesLoopie candidate 223042721\.421\.42\\times0\.630\.63\\timesLoopie candidate 324322821\.651\.65\\times0\.690\.69\\timesWe conduct large\-scale benchmarking of each candidate configuration in Megatron\-LM, following the matching protocol described above\. For the reference model and each candidate model, we jointly search over tensor parallelism, expert parallelism, and microbatch size\. We then select the candidate whose measured optimizer\-step time is closest to that of the non\-recurrent reference model:

D1=2304,L1=27,R1=2,D\_\{1\}=2304,\\qquad L\_\{1\}=27,\\qquad R\_\{1\}=2,which defines Loopie\-20B\-A2B\.

At the reference per\-device microbatch size, the dominant activation memory proxy of Loopie\-20B\-A2B relative to the reference is

D1​L1D0​L0=230427204848​0\.633\.\\frac\{D\_\{1\}L\_\{1\}\}\{D\_\{0\}L\_\{0\}\}=\\frac\{2304\\cdot 27\}\{2048\\cdot 48\}\\approx 0\.633\.This expression is a scaling proxy rather than an exact peak\-memory equation\. Candidate feasibility is therefore determined using the measured full memory footprint, which also includes parameters, optimizer states, temporary buffers, and communication workspaces\. The measured memory profile of Loopie\-20B\-A2B permits the per\-device microbatch size to be doubled:

b1=2​b0,g1=g02\.b\_\{1\}=2b\_\{0\},\\qquad g\_\{1\}=\\frac\{g\_\{0\}\}\{2\}\.This leaves the number of tokens per optimizer step unchanged\. The selected model has a normalized leading\-order Transformer block compute proxy of

Cwidehat1Cwidehat0=272230424820482​1\.424\.\\frac\{\\widehat\{C\}\_\{1\}\}\{\\widehat\{C\}\_\{0\}\}=\\frac\{27\\cdot 2\\cdot 2304^\{2\}\}\{48\\cdot 2048^\{2\}\}\\approx 1\.424\.Loopie\-20B\-A2B matches the reference optimizer\-step time only after changing the schedule from\(b0,g0\)\(b\_\{0\},g\_\{0\}\)to\(2​b0,g0/2\)\(2b\_\{0\},g\_\{0\}/2\); thus, the measured efficiency gain is entirely attributable to the doubled microbatch size\.

The compute\-matching criterion is therefore the directly measured relation:

tstep​\(D1,L1,R1;2​b0,g0/2\)​tstep​\(D0,L0,R0;b0,g0\),t\_\{\\mathrm\{step\}\}\\left\(D\_\{1\},L\_\{1\},R\_\{1\};2b\_\{0\},g\_\{0\}/2\\right\)\\approx t\_\{\\mathrm\{step\}\}\\left\(D\_\{0\},L\_\{0\},R\_\{0\};b\_\{0\},g\_\{0\}\\right\),rather than an analytical prediction based onCwidehat\\widehat\{C\}\. The leading\-order compute proxy omits lower\-order operators, routing and communication costs, optimizer overhead, kernel\-launch overhead, and the effect of the microbatch schedule on realized hardware utilization\. It is therefore used to characterize nominal work, not to replace end\-to\-end timing\. We evaluated the Loopie Recipe across multiple GPU platforms and observed consistent infrastructure\-level gains\.

The Loopie Recipe therefore does not claim equality in analytical FLOP estimates\. It uses layer\-loop recurrence to reduce the stored memory footprint, converts the resulting memory headroom into a doubled per\-device microbatch size, spends the measured microbatch efficiency gain on additional model capacity, and selects the final architecture using measured end\-to\-end optimizer\-step time\.

![Refer to caption](https://arxiv.org/html/2607.16051v2/x5.png)Figure 3:Comparison of Loopie\-20B\-A2B with our reproduction of Qwen3\-30B\-A3B under matched per\-step pre\-training wall\-clock time in Megatron\-LM\. The left panel reports the average score across eight downstream benchmarks, while the right panel reports the highest average pre\-training throughput achieved for each model during large\-scale benchmarking\. In the right figure, Loopie\-20B\-A2B uses EP = 8 and MBS = 2, while Qwen3\-30B\-A3B uses EP = 8 and MBS = 1\. These configurations achieve the highest throughput in a large\-scale TP/PP/EP/MBS grid search; the optimal settings may vary across different GPU\.

### 2\.5Results

To test this principle, we compare Loopie against a strong non\-recurrent baseline based on the Qwen3\-MoE design\. Specifically, we train a vanilla 30B\-A3B MoE Transformer with a Qwen3\-like architecture on 800 billion tokens under the same pre\-training compute budget used for Loopie\-20B\-A2B\. As shown in Figure[3](https://arxiv.org/html/2607.16051#S2.F3), Loopie initially lags behind the larger vanilla baseline during the early phase of training\. However, after roughly 600 billion tokens of pre\-training, Loopie\-20B\-A2B overtakes the compute\-matched baseline and maintains a consistent advantage thereafter\. This result suggests that, with the right scaling recipe, looped MoE models can achieve stronger final performance by using recurrent computation than by allocating the same compute to a larger vanilla Transformer\.

### 2\.6Scalability

A practical recurrent architecture should not only outperform a single compute\-matched baseline but also remain effective as the model is scaled\. Many architectural ideas show promising results at one small scale yet fail at larger scales for various reasons\. We therefore evaluate whether the Loopie design preserves its advantage across a sequence of increasingly large pre\-training runs\.

![Refer to caption](https://arxiv.org/html/2607.16051v2/x6.png)Figure 4:Scaling ladder for Loopie\. The horizontal axis denotes the parameter count of the non\-recurrent baseline, and the vertical axis reports the average score across eight downstream benchmarks\. The Loopie models are not plotted at the parameter counts indicated on the horizontal axis; instead, each Loopie model is sized according to the Loopie Recipe so that its per\-step pre\-training wall\-clock time exactly matches that of the corresponding baseline\.We construct a scaling ladder consisting of four non\-recurrent MoE baselines and four compute\-matched Loopie models\. Each Loopie model is obtained by transforming a non\-recurrent MoE baseline using the Loopie Recipe\. At each rung, the Loopie model uses two layer\-loop steps, and its stored width and depth are chosen according to the same compute\-matched principle described in Section[2\.4](https://arxiv.org/html/2607.16051#S2.SS4)\. The goal of this ladder is not to match the stored parameter count but to match the effective pre\-training compute of the corresponding vanilla baseline\. Thus, the Loopie models contain fewer stored parameters while using recurrence to increase effective depth\.

For each reference model, we train on a token count equal to 1000× its active MoE parameter count, ensuring that each model is sufficiently overtrained and that its downstream metrics have largely stabilized\. We use the same token budget for the corresponding Loopie models, even though these models have fewer active parameters\.

For the smallest rung, we train the 0\.15B vanilla baseline and its compute\-matched 0\.10B Loopie counterpart on 150B tokens, placing the models in a heavily overtrained regime relative to standard Chinchilla\-style compute\-optimal prescriptions\. For the 0\.25B and 0\.50B rungs, we train on 250B and 500B tokens, respectively\. For the 1B vanilla baseline and the corresponding 0\.70B Loopie model, we also train on 500B tokens due to limited compute\. The architectural details for this scaling ladder are provided in Appendix Table[7](https://arxiv.org/html/2607.16051#Ax3.T7)\.

Figure[4](https://arxiv.org/html/2607.16051#S2.F4)summarizes the resulting scaling behavior\. Across all four rungs, Loopie consistently outperforms its compute\-matched vanilla counterpart\. More importantly, the gap does not vanish as model size increases\. This suggests that Loopie’s advantage persists across a meaningful scaling ladder rather than being merely a small\-model artifact\. The result supports the central design hypothesis of the Loopie Series: recurrent layer\-loop computation can be converted into scalable modeling gains when stored width, stored depth, and recurrent depth are jointly chosen under a fixed compute budget\.

Taken together, the scaling ladder provides evidence that Loopie remains effective beyond an isolated compute\-matched comparison\. As the baseline parameter count grows from 0\.15B to 1B, Loopie models continue to deliver stronger downstream accuracy under matched pre\-training budgets\. This behavior is important for large\-scale deployment: it indicates that the layer\-loop design and the Loopie Recipe are compatible with progressive scaling rather than being limited to a narrow model\-size regime\.

### 2\.7Ablations

![Refer to caption](https://arxiv.org/html/2607.16051v2/x7.png)Figure 5:Layer\-loop ablation for Loopie\-6B\-A0\.6B\. We report the average score across eight downstream benchmarks for Loopie\-6B\-A0\.6B and Loopie\-6B\-A0\.6B\-Ablation\. Loopie\-6B\-A0\.6B\-Ablation matches Loopie\-6B\-A0\.6B in all architectural details except for the removal of layer\-loop recurrence\.In addition to comparing Loopie against a compute\-matched vanilla MoE baseline, we further isolate the contribution of the*layer\-loop*recurrence schedule\. To do so, we conduct a controlled experiment by training a 6B\-A0\.6B MoE model with the same backbone, optimizer, data mixture, and token budget as Loopie\-6B\-A0\.6B but with the layer\-loop pattern removed\. This ablated model therefore preserves the overall looped computation budget while testing whether the ordering of recurrent computation is itself important\.

Figure[5](https://arxiv.org/html/2607.16051#S2.F5)shows the resulting average score across eight downstream benchmarks\. The layer\-loop pattern substantially improves downstream performance relative to the matched ablation\. Importantly, because neither the number of active parameters nor the overall computation budget increases, the improvement cannot simply be attributed to additional computation\.

This result supports the architectural choice made in Loopie\. While recurrence increases effective depth, the way recurrence is scheduled matters: naively looping computation is insufficient to achieve high compute efficiency\. These ablations suggest that Loopie’s gains arise not only from using recurrence but from using recurrence in a form that is aligned with the hierarchical structure of Transformer representations\.

### 2\.8Why Only Two Loop Steps?

Many recurrent language model designs use substantially deeper unrolling\. For example, prior looped or latent\-recurrent models often use 4, 16, or even more than 30 recurrent steps\(zhu2025scalinglatent;geiping2025scalinglatent\)\. These settings are useful for studying recurrence as a general mechanism for iterative computation\. Loopie targets a different regime: large\-scale language model pre\-training under a fixed compute budget\. In this regime, the number of loop steps is not merely an architectural hyperparameter; it is a direct allocation of pre\-training FLOPs\.

At a fixed stored parameter count and a fixed number of optimizer steps, increasing the number of loop steps usually improves the training curve\. However, this comparison is not compute\-matched\. For a model withRRloop steps, the per\-token training cost scales approximately linearly withRR, up to MoE routing and implementation constants:

𝒞​\(D,L,R\)​L​D2​R\.\\mathcal\{C\}\(D,L,R\)\\propto LD^\{2\}R\.Under the same pre\-training budget, the model must either be trained on fewer tokens, use a smaller stored architecture, or be compared against a stronger non\-recurrent model that spends the same compute on ordinary Transformer capacity\. The relevant question is thus not whether a model withR=4R=4outperforms one withR=2R=2at the same stored size but whether the marginal gain from additional recurrence exceeds the gain that could be obtained by reallocating the same FLOPs to width, depth, or data\.

![Refer to caption](https://arxiv.org/html/2607.16051v2/)Figure 6:Comparison betweenNN\\timeslayer\-loop andNN\\timesstored\-layer scaling\. We report the average score across eight downstream benchmarks after training each model on 250B tokens while keeping all other architectural details fixed\. The shaded gray region denotes the gap between theNN\\timeslayer baseline and theNN\\timesloop model\.Our loop\-count sweep suggests that this marginal return decays rapidly in the large\-scale pre\-training regime\. To isolate whether the gain comes from recurrence rather than simply adding more non\-shared layers, we compare a model that usesNN\\timeslayer\-loop steps with one that hasNN\\timesas many stored layers, while holding all other architectural details fixed\. Figure[6](https://arxiv.org/html/2607.16051#S2.F6)reports the average score across eight downstream benchmarks after the models are trained on 250B tokens\. The shaded gray region highlights the performance gap between theNN\\timeslayer baseline and theNN\\timesloop model\. For the22\\timescomparison, we use a22\\timesstored\-layer model only as a conservative proxy for the previous compute\-matched setting\. Because this model is very small, with only 0\.25B active parameters, precise compute matching is difficult under multiple practical constraints, so the actual training compute of the22\\timeslayer baseline is substantially higher than that of the22\\timesloop model\. Thus, the figure should not be read as evidence that22\\timeslooping is dominated by22\\timeslayer scaling; rather, it shows that, when comparingNN\\timeslooping againstNN\\timesstored\-layer scaling, the marginal benefit of recurrence is largest atR=2R=2\.

We therefore chooseR=2R=2for the Loopie Series\. This is the smallest nontrivial recurrent setting: each layer performs one ordinary transformation followed by one local refinement step before passing its representation to the next layer\. This permits recurrence to change the computation qualitatively while keeping the compute multiplier small enough for scalable pre\-training\. It also preserves training throughput and makes the comparison against Qwen3\-like vanilla MoE baselines stringent: Loopie must outperform these baselines not by using a large amount of extra recurrent computation but by using a small amount of recurrence more effectively\.

This choice should not be interpreted as claiming that larger loop counts are ineffective in isolation\. LargerRRmay be useful in settings where inference\-time computation is cheap, where adaptive computation is available, or where the goal is to study recurrent reasoning rather than pre\-training efficiency\. For frontier\-scale pre\-training, however, the dominant constraint is total compute\. Under this constraint,R=2R=2provides the best trade\-off we observe between iterative refinement, throughput, and compute\-matched scaling\.

## 3Pre\-Training

We pre\-train Loopie models in two stages\. In the first stage, we perform large\-scale pre\-training from scratch on 3T tokens\. In the second stage, we conduct high\-quality data annealing using 1\.26T tokens, with an emphasis on high\-quality synthetic, STEM, code, mathematical reasoning, and web data\. All Loopie models use the tokenizer from the Qwen3 model family\(qwen3\)\. We conduct all pre\-training using the Megatron\-LM\(megatron\-lm\)framework\.

### 3\.1Evaluation

We evaluate the pre\-trained checkpoints using the LM Evaluation Harness framework\(eval\-harness\)\. For all experiments in Section 2, we report the mean score across the following eight benchmarks: ARC\-Challenge\(clark2018think\), ARC\-Easy\(clark2018think\), BoolQ\(clark2019boolq\), CommonsenseQA\(talmor2019commonsenseqa\), HellaSwag\(zellers2019hellaswag\), MMLU\(hendrycks2021measuring\), OpenBookQA\(mihaylov2018openbookqa\), and WinoGrande\(sakaguchi2020winogrande\)\.

### 3\.2Initialization

Letdddenote the model width\. We initialize the token embedding matrixEEand the language\-modeling headWlmW\_\{\\mathrm\{lm\}\}—or the shared embedding/unembedding matrix when weight tying is used—asEi​j,\(Wlm\)i​j​𝒩​\(0,d−1\)E\_\{ij\},\(W\_\{\\mathrm\{lm\}\}\)\_\{ij\}\\sim\\mathcal\{N\}\(0,d^\{\-1\}\)\. On the input side, the looked\-up embeddings are multiplied byd\\sqrt\{d\}before entering the residual stream, so that the embedding shortcut hasO​\(1\)O\(1\)activation scale, while the samed−1d^\{\-1\}variance ensures that the initial logitsh​whwhaveO​\(1\)O\(1\)variance for normalized hidden states\(shazeer2018adafactor;takase2025spike\)\. For hidden\-to\-hidden parameters inside Transformer blocks, including attention projections and feed\-forward layers, we use SmallInit:

Wi​j​𝒩​\(0,25​d\),std⁡\(W\)=12\.5​d\.W\_\{ij\}\\sim\\mathcal\{N\}\\\!\\left\(0,\\frac\{2\}\{5d\}\\right\),\\qquad\\operatorname\{std\}\(W\)=\\frac\{1\}\{\\sqrt\{2\.5d\}\}\.This scale corresponds to Xavier fan\-in/fan\-out initialization for a Transformer FFN with an expansion ratio of44, sincedin\+dout=d\+4​d=5​dd\_\{\\rm in\}\+d\_\{\\rm out\}=d\+4d=5d\. We also apply this scale to attention projections to reduce the scale of residual\-branch sub\-layers\(glorot2010understanding;nguyen2019transformers\)\. Thus, we used−1/2d^\{\-1/2\}for embeddings/unembeddings, which determine the shortcut and logit scales, but\(2\.5​d\)−1/2\(2\.5d\)^\{\-1/2\}for block sub\-layers, whose Jacobians should remain small for stable pre\-training\(takase2025spike\)\.

### 3\.3Learning Schedule

We optimize all models with AdamW\(kingma2015adam;loshchilov2019decoupled\)\. We set the peak learning rate to510−45\\times 10^\{\-4\}forLoopie\-6B\-A0\.6Band310−43\\times 10^\{\-4\}forLoopie\-20B\-A2B\. We set the AdamW hyperparameters toβ1=0\.9\\beta\_\{1\}=0\.9,β2=0\.95\\beta\_\{2\}=0\.95, andϵ=10−15\\epsilon=10^\{\-15\}, use a weight decay of0\.10\.1, and apply global gradient\-norm clipping at1\.01\.0\. We use a warmup\-stable\-only learning\-rate schedule\. After a specified number of warmup steps—6,000 steps for Loopie\-20B\-A2B and 2,000 steps for Loopie\-6B\-A0\.6B—the learning rate reaches its peak value and then remains constant without decay\. This decay\-free stable phase keeps the effective update scale high after warmup, avoiding the diminished influence of late\-stage high\-quality data that can occur under annealed schedules\(wen2024understanding;luo2025learning;yano2026pretraining\)\. We also use a constant learning rate during the high\-quality annealing phase in Stage 2 to maximize learning from the highest\-quality annealing data\(luo2025learning\)\. The global batch size is 1024, and the sequence length is 8192\.

### 3\.4Stage 1: Multi\-Epoch High\-Quality Pre\-Training

In Stage 1, we train both Loopie\-20B\-A2B and Loopie\-6B\-A0\.6B on Nemotron\-CC\-v2\-HQ\(nemotron\-cc\), a high\-quality subset of Nemotron\-CC\. The corpus contains approximately 570B unique tokens, and we train for four epochs, totaling approximately 2\.28T training tokens\. This design is motivated by our prior observation that repeated training on high\-quality data can be more effective than single\-pass training on a larger corpus of lower average quality\(gao2025makesdiffusionlanguagemodels\)\.

### 3\.5Stage 2: High\-Quality Annealing

In Stage 2, we construct a high\-quality annealing mixture from Nemotron pre\-training datasets\. The resulting pool contains approximately 1\.26T tokens\. The mixture combines high\-quality SFT\-style data, synthetic reasoning data, code data, synthetic web data, and math data\. In total, the pool contains approximately 1263B tokens: 351B from Nemotron\-pre\-training\-SFT\-v1 \(27\.8%\), 277B from Nemotron\-pre\-training\-Specialized\-v1 \(21\.9%\), 262B from a 60% sample of Nemotron\-pre\-training\-Code\-v2 \(20\.7%\), 197B from a 16% sample of Nemotron\-CC\-v2\-HQ\-Synthetic \(15\.6%\), 126B from Nemotron\-CC\-Math\-v1 with quality scores4\\geq 4\(10\.0%\), 25B from Nemotron\-CC\-v2\.1\-HQ \(2\.0%\), and 25B from Nemotron\-CC\-v2\.1\-HQ\-Synthetic \(2\.0%\)\. Figure[7](https://arxiv.org/html/2607.16051#S3.F7)visualizes these relative proportions\.

![Refer to caption](https://arxiv.org/html/2607.16051v2/x9.png)Figure 7:Composition of the Stage\-2 high\-quality annealing data pool: multiple data sources make up the 1\.26T\-token annealing recipe\.#### Nemotron\-pre\-training\-SFT\-v1\.

We include approximately 351B tokens from Nemotron\-pre\-training\-SFT\-v1, a diverse SFT\-style dataset of synthetic and curated examples spanning STEM, academic, code, mathematics, and reasoning domains, with multilingual coverage\. Its STEM component is expanded from high\-quality math and science seeds through iterative generation with Qwen3 and DeepSeek models, producing harder and more varied questions with solutions\. The dataset also contains academic question\-answer pairs synthesized from undergraduate\- and graduate\-level texts, as well as MMLU\-style general QA and fundamental reasoning data\.

#### Nemotron\-pre\-training\-Specialized\-v1\.

We include approximately 277B tokens from Nemotron\-pre\-training\-Specialized\-v1, which comprises synthetic data for STEM reasoning, scientific coding, and cross\-domain coding, as well as synthetic Wikipedia data and synthetic mathematics textbook data\. The STEM reasoning component includes reasoning question\-answer demonstrations generated from advanced scientific seed documents, while the scientific coding and cross\-domain coding subsets introduce graduate\- or research\-level programming tasks with structured solutions\. This data is intended to strengthen scientific reasoning, mathematical abstraction, and code generation during annealing\.

#### Nemotron\-pre\-training\-Code\-v2\.

We randomly sample 60% of Nemotron\-pre\-training\-Code\-v2, yielding approximately 262B tokens\. This dataset combines recent GitHub source code, synthetic code\-grounded question\-answer data, student\-teacher dialogues, code\-review dialogues, and LLM\-rewritten or transpiled source code\. The rewriting and transpilation components are designed to improve downstream code generation by increasing stylistic diversity and exposing the model to semantically equivalent code variants\.

#### High\-quality synthetic web data\.

We randomly sample 16% of Nemotron\-CC\-v2\-High\-Quality\-Synthetic, yielding approximately 197B tokens\. This dataset is derived from Nemotron\-CC\-v2 and contains English web\-crawl documents augmented through synthetic rephrasing with Qwen3\-30B\-A3B\. We further include 25B tokens from Nemotron\-CC\-v2\.1\-High\-Quality\-Synthetic, which extends the synthetic high\-quality web corpus with newer Common Crawl snapshots and additional rephrased medium\- to high\-quality documents\.

#### High\-quality web data\.

We include approximately 25B tokens from Nemotron\-CC\-v2\.1\-High\-Quality\. This subset incorporates recent Common Crawl snapshots and high\-quality data translated into English from multiple languages\. Additional LLM\-based filtering removes uninformative translated documents\. The inclusion of this data preserves exposure to natural web text during the annealing phase\.

#### Mathematics data\.

Finally, we include approximately 126B tokens from Nemotron\-CC\-Math\-v1, using only documents with quality scores of 4 and above\. Nemotron\-CC\-Math\-v1 is a high\-quality math pre\-training corpus built from Common Crawl using a pipeline designed to preserve equations and code, convert mathematical notation to standardized LaTeX, and remove noise\. This component is included to strengthen mathematical reasoning and symbolic problem\-solving capabilities\.

## 4Post\-Training

Pre\-TrainingHigh\-QualityAnnealingLoopieBaseSupervisedPre\-TrainingMath RLLoopieThinking

Figure 8:Overview of the Loopie training pipeline\. The model is first pre\-trained and annealed to produceLoopie Base, which then undergoes supervised pre\-training and Math RL to produceLoopie Thinking\.Loopie’s post\-training recipe consists of two main stages following Stage 2 high\-quality annealing\. First, we introduce a supervised pre\-training stage in which we continue training the model on 2T tokens of instruction\-following, reasoning, coding, mathematics, and tool\-use data, allowing the base model to acquire broad task\-following and problem\-solving capabilities while preserving the knowledge and general capabilities learned during pre\-training\. Second, we apply large\-scale reinforcement learning to further enhance Loopie’s reasoning capabilities, improve its long\-horizon problem solving, and align the model so that it produces reliable thinking traces\. Together, these stages transformLoopie Baseinto the finalLoopie Thinkingmodel\.

### 4\.1Supervised Pre\-Training

We introduce*supervised pre\-training*\(SPT\), a training regime that combines the supervision pattern of supervised fine\-tuning \(SFT\) with the optimization scale of language\-model pre\-training \(PT\)\. SPT uses exactly the same training data and token\-level objective as SFT: prompt and context tokens are excluded from the loss, and only supervised target tokens contribute to optimization\. Unlike conventional SFT, however, SPT uses global batch sizes, sequence lengths, and token budgets typical of language\-model pre\-training\.

Table 2:Comparison of supervised pre\-training \(SPT\), conventional supervised fine\-tuning \(SFT\), and pre\-training \(PT\)\. The SPT column reports the representative configuration used forLoopie\.\\uparrow\\uparrow,\\downarrow\\downarrow, and indicate improvement, degradation, and no material change, respectively, relative to the corresponding starting checkpoint\. Stability entries summarize our observations over the evaluated training horizon rather than universal guarantees\.SPTSFTPTLoss functionCross\-entropyCross\-entropyCross\-entropyLoss\-bearing positionsSupervised target tokens onlySupervised target tokens onlyAll non\-padding tokensPre\-training metrics\\uparrow\\uparrow\\downarrow\\downarrow\\uparrow\\uparrowReasoning metrics\\uparrow\\uparrow\\uparrow\\uparrowOverfitting after multiple epochsNot observedObservedNot observedGlobal batch size1,024\\geq 1\{,\}0243232–1281281,024\\geq 1\{,\}024Sequence length128​K\\geq 128\\,\\mathrm\{K\}88–32​K32\\,\\mathrm\{K\}44–8​K8\\,\\mathrm\{K\}Nominal token positions per batch128​M\\geq 128\\,\\mathrm\{M\}128​K128\\,\\mathrm\{K\}–1​M1\\,\\mathrm\{M\}88–32​M32\\,\\mathrm\{M\}Total training token budget2​T\\geq 2\\,\\mathrm\{T\}1010–100​B100\\,\\mathrm\{B\}4​T\\geq 4\\,\\mathrm\{T\}SPT separates two design choices that are commonly coupled: \(i\) which tokens contribute to the training loss, and \(ii\) the scale at which optimization is performed\. SFT and SPT share the former choice, whereas PT and SPT share the latter\. Consequently, SPT does not interpolate between an SFT loss and a PT loss\. Instead, it applies an SFT\-style supervised objective in a PT\-scale optimization regime\.

#### Training objective\.

Consider a supervised examplezi=\[ci;yi\]z\_\{i\}=\[c\_\{i\};y\_\{i\}\], wherecic\_\{i\}denotes the input context andyiy\_\{i\}denotes the supervised target response\. Letwi,t​\{0,1\}w\_\{i,t\}\\in\\\{0,1\\\}be a binary loss mask for the token at positiontt\. All three training regimes use token\-level cross\-entropy:

ℒCE​\(θ;w\)=−\\slimits@i=1B​\\slimits@t=1Ti​wi,t​log⁡pθ​\(zi,t​zi,<t\)\\slimits@i=1B​\\slimits@t=1Ti​wi,t\.\\mathcal\{L\}\_\{\\mathrm\{CE\}\}\(\\theta;w\)=\-\\frac\{\\displaystyle\\tsum\\slimits@\_\{i=1\}^\{B\}\\tsum\\slimits@\_\{t=1\}^\{T\_\{i\}\}w\_\{i,t\}\\log p\_\{\\theta\}\\left\(z\_\{i,t\}\\mid z\_\{i,<t\}\\right\)\}\{\\displaystyle\\tsum\\slimits@\_\{i=1\}^\{B\}\\tsum\\slimits@\_\{t=1\}^\{T\_\{i\}\}w\_\{i,t\}\}\.For both SPT and SFT,wi,t=1w\_\{i,t\}=1only whenzi,tz\_\{i,t\}belongs to the supervised targetyiy\_\{i\}; prompt, context, and padding positions are masked out\. In conventional PT, by contrast,wi,t=1w\_\{i,t\}=1for every non\-padding token\. Thus, all three regimes employ the same cross\-entropy loss, but differ in the positions to which the loss is applied and in the scale of optimization\.

Table[2](https://arxiv.org/html/2607.16051#S4.T2)summarizes these distinctions\. For representative SFT settings, including global batch sizes, training token counts, and sequence lengths, we primarily follow the configurations reported for OLMo 3, the Nemotron 3 series, and Step\-3\.5\-Flash\(olmo2026olmo3;nvidia2025nemotron3nanoopen;bercovich2025llamanemotronefficientreasoningmodels;nvidia2026nemotron3superopen;nvidia2026nemotron3ultraopen;huang2026step35flashopen\)\. We use*pre\-training metrics*to refer to metrics that evaluate general base\-model capabilities and*reasoning metrics*to refer to metrics that primarily evaluate performance on challenging reasoning tasks, such as competition\-level mathematics and coding problems\. In our experiments, SPT improves performance on both types of metrics simultaneously\. In contrast, the conventional SFT baseline only improves performance on reasoning metrics but degrades performance on pre\-training metrics, whereas PT improves pre\-training metrics performance while leaving performance on reasoning metrics approximately unchanged\.

![Refer to caption](https://arxiv.org/html/2607.16051v2/x10.png)Figure 9:Training loss for Loopie\-6B\-A0\.6B during supervised pre\-training\. Because the evaluation and training loss curves nearly overlap, only the training loss curve is shown\. Over 10 epochs of supervised pre\-training on a total of 2 trillion tokens, the loss decreases smoothly, with no loss cliff observed at epoch boundaries\.![Refer to caption](https://arxiv.org/html/2607.16051v2/x11.png)Figure 10:Trends in reasoning metrics during supervised pre\-training\. Throughout training on 2 trillion tokens, performance on the reasoning metrics continues to improve, with no sign of slowing\.
#### Pre\-training\-scale optimization over supervised data\.

SPT processes 128 million tokens per global batch, approximately 1,000 times the number processed per batch in conventional SFT\. This makes overfitting much less likely in SPT than in standard SFT\. This scale gives SPT distinct training dynamics, consistent with observations that optimization hyperparameters and scaling behavior can change in large\-language\-model training regimes\(jin2023rethinkinglearningratetuning\)\. Under SPT, the model can be trained smoothly for substantially more epochs without showing signs of overfitting, such as abrupt drops in loss at epoch boundaries\. At the same time, performance on downstream metrics continues to improve steadily\. In addition, SPT mitigates catastrophic forgetting\(wu2024mitigating\), which is a major drawback of conventional SFT and typically causes substantial degradation of the general knowledge acquired during pre\-training\. Notably, SPT not only avoids this degradation but also further improves general\-knowledge performance\.

As shown in Figure[11](https://arxiv.org/html/2607.16051#S4.F11), SPT consistently improves performance on downstream pre\-training metrics, including ARC\-Challenge and MMLU, throughout approximately 10 epochs of training on 2T tokens\. This finding challenges the conventional view that SFT leads to catastrophic forgetting\.

![Refer to caption](https://arxiv.org/html/2607.16051v2/x12.png)Figure 11:Trends in pre\-training metrics during supervised pre\-training\. ARC\-Challenge represents general reasoning performance, while MMLU represents general knowledge performance\. Throughout training on 2 trillion tokens, performance on the pre\-training metrics does not degrade; instead, it continues to improve\.Simply running a conventional SFT configuration for more epochs does not reproduce the optimization regime of SPT\. Conventional\-scale SFT often begins to overfit between the second and fourth epochs\. In small\-batch SFT, each epoch involves many parameter updates computed from small batches, and repeated exposure to the same examples can lead to rapid specialization and memorization\. In contrast, every SPT update aggregates supervision from more than one thousand sequences and over one hundred million nominal token positions\. We hypothesize that this broad gradient aggregation, together with long contexts and a large token budget, mitigates the overly narrow specialization commonly observed during repeated SFT\.

### 4\.2Reinforcement Learning

After SPT, we apply a reinforcement\-learning stage to obtainLoopie Thinking\. Following prior work, we do not mix data from multiple domains during training because domain\-specific length biases may interfere with one another\(chen2026acereasonnemotron;liu2026acereasonnemotron\)\. We first conduct reinforcement learning on mathematical tasks; once performance saturates, we continue with reinforcement learning on coding tasks\.

#### Algorithm\.

Our optimizer builds on Group Sequence Policy Optimization \(GSPO\)\(zheng2025groupsequencepolicyoptimization\), with the asymmetric clipping and dynamic sampling techniques introduced by DAPO\(yu2025dapo\)\. For each promptqq, we sample a group ofGGcompletions\{oi\}i=1G\\\{o\_\{i\}\\\}\_\{i=1\}^\{G\}from the old policyπθold\\pi\_\{\\theta\_\{\\mathrm\{old\}\}\}and score each completion using a verifier, yielding outcome rewards\{Ri\}i=1G\\\{R\_\{i\}\\\}\_\{i=1\}^\{G\}\. We estimate sequence\-level advantages by normalizing rewards within the sampled group:

A^i=Ri−mean⁡\(\{Rj\}j=1G\)std⁡\(\{Rj\}j=1G\)\+ϵ,\\hat\{A\}\_\{i\}=\\frac\{R\_\{i\}\-\\operatorname\{mean\}\(\\\{R\_\{j\}\\\}\_\{j=1\}^\{G\}\)\}\{\\operatorname\{std\}\(\\\{R\_\{j\}\\\}\_\{j=1\}^\{G\}\)\+\\epsilon\},whereϵ\\epsilonis a small numerical constant\.

Unlike token\-level policy optimization, GSPO defines a length\-normalized sequence\-level importance ratio:

si​\(θ\)=\(πθ​\(oi​q\)πθold​\(oi​q\)\)1\|oi\|=exp⁡\(1\|oi\|​\\slimits@t=1\|oi\|​log⁡πθ​\(oi,t​q,oi,<t\)πθold​\(oi,t​q,oi,<t\)\)\.s\_\{i\}\(\\theta\)=\\left\(\\frac\{\\pi\_\{\\theta\}\(o\_\{i\}\\mid q\)\}\{\\pi\_\{\\theta\_\{\\mathrm\{old\}\}\}\(o\_\{i\}\\mid q\)\}\\right\)^\{\\frac\{1\}\{\|o\_\{i\}\|\}\}=\\exp\\left\(\\frac\{1\}\{\|o\_\{i\}\|\}\\tsum\\slimits@\_\{t=1\}^\{\|o\_\{i\}\|\}\\log\\frac\{\\pi\_\{\\theta\}\(o\_\{i,t\}\\mid q,o\_\{i,<t\}\)\}\{\\pi\_\{\\theta\_\{\\mathrm\{old\}\}\}\(o\_\{i,t\}\\mid q,o\_\{i,<t\}\)\}\\right\)\.That is,si​\(θ\)s\_\{i\}\(\\theta\)is the geometric mean of the token\-level importance ratios over the response\. The length normalization reduces the variance of the sequence\-level ratio and keeps responses of different lengths within a comparable numerical range\.

The policy is optimized using a sequence\-level clipped objective:

𝒥RLGSPO​\(θ\)=𝔼q​𝒟,\{oi\}i=1G​πθold​\(q\)​\[1G​\\slimits@i=1G​min⁡\(si​\(θ\)​A^i,clip⁡\(si​\(θ\),1−ϵlow,1\+ϵhigh\)​A^i\)\]\.\\mathcal\{J\}\_\{\\mathrm\{RL\}\}^\{\\mathrm\{GSPO\}\}\(\\theta\)=\\mathbb\{E\}\_\{q\\sim\\mathcal\{D\},\\,\\\{o\_\{i\}\\\}\_\{i=1\}^\{G\}\\sim\\pi\_\{\\theta\_\{\\mathrm\{old\}\}\}\(\\cdot\\mid q\)\}\\left\[\\frac\{1\}\{G\}\\tsum\\slimits@\_\{i=1\}^\{G\}\\min\\left\(s\_\{i\}\(\\theta\)\\hat\{A\}\_\{i\},\\,\\operatorname\{clip\}\\left\(s\_\{i\}\(\\theta\),1\-\\epsilon\_\{\\mathrm\{low\}\},1\+\\epsilon\_\{\\mathrm\{high\}\}\\right\)\\hat\{A\}\_\{i\}\\right\)\\right\]\.In contrast to token\-level clipping, GSPO applies the clipping operation to the entire response\. Consequently, all tokens in the same response share the same sequence\-level importance weight, aligning the unit of off\-policy correction and optimization with the unit of reward\.

Following the Clip\-Higher strategy, we useϵhigh\>ϵlow\\epsilon\_\{\\mathrm\{high\}\}\>\\epsilon\_\{\\mathrm\{low\}\}\. Under GSPO, this asymmetric clipping is applied to the sequence\-level importance ratio rather than individual token\-level ratios\. The larger upper clipping range allows positively advantaged exploratory responses to receive stronger probability\-increasing updates, while the more conservative lower clipping range limits excessive probability decreases for negatively advantaged responses\.

We further apply prompt\-level dynamic filtering\. A prompt is retained only when its sampled group contains both successful and unsuccessful completions:

0<\\slimits@i=1G​𝟏​\{Ri=Rpass\}<G\.0<\\tsum\\slimits@\_\{i=1\}^\{G\}\\mathbf\{1\}\\\{R\_\{i\}=R\_\{\\mathrm\{pass\}\}\\\}<G\.Groups that are entirely correct or entirely incorrect provide no useful relative preference signal for GRPO\. We therefore oversample candidate prompts and filter out such groups until the effective batch is full\. This keeps the optimization focused on prompts that yield non\-degenerate policy gradients\.

#### Training data\.

We use the mathematics and code subsets of the Guru\-RL corpus\(cheng2025guru\)\. The mathematics pool is drawn from the OR1, DAPO, and DeepScaleR sources\(he2025skywork;yu2025dapo;tan2025deepscaler\)\. The code pool combines LeetCodeDataset, TACO\-Verified, PrimeIntellect/SYNTHETIC\-1, and historical LiveCodeBench training problems\(xia2025leetcodedataset;li2023taco;li2024tacoverified;mattern2025synthetic1;jain2024livecodebench\)\. We apply an additional curation pass that removes malformed prompts, unverifiable answers, flaky tests, duplicate examples, and examples that substantially overlap with held\-out evaluation sets\. Rewards for mathematical problems are computed using rule\-based answer equivalence, whereas rewards for coding problems are computed using sandboxed unit\-test execution\.

#### Training schedule\.

We train in two context\-length stages\. The first stage uses a maximum response length of3232K tokens\. This stage is computationally efficient because most rollouts terminate naturally within this limit\. When the rollout truncation rate exceeds10%10\\%, we switch to a6464K\-token stage, giving the policy additional room for longer derivations and code\-reasoning trajectories\. We continue RL until the aggregate validation score stops improving and begins to decline; the checkpoint immediately before sustained degradation is selected asLoopie Thinking\. Throughout training, we monitor validation accuracy, mean response length, generation entropy, and truncation rate to detect late\-stage over\-optimization\.

### 4\.3Results

We report two complementary comparisons of the final Loopie Thinking models\. We compare Loopie\-20B\-A2B with MoE reasoning models at a similar active\-parameter scale, and Loopie\-6B\-A0\.6B with a broader set of compact reasoning models\. All evaluations in this section are conducted using the EvalScope framework, and the IFEval score is reported under theinst\_level\_loosesetting\. For AIME 2024 and AIME 2025, we report avg@@8 results; for all other benchmarks, we report pass@@1\. The AIME result shown in the teaser figure is for AIME 2024\.

Table 3:Comparison of Loopie\-20B\-A2B with similarly sized MoE reasoning models across knowledge, general, code, and math benchmarks\.Qwen330B\-A3BThinkingNemotron3 Nano30B\-A3BNemotronCascade 230B\-A3BGPT\-OSS20B\-A2BHighLoopie20B\-A2BThinkingPre\-training tokens36T25T25TUnknown3\.5TKnowledgeMMLU85\.8380\.5281\.2281\.6481\.28MMLU\-Redux88\.2582\.5483\.8983\.4083\.61GeneralARC\-Challenge96\.6791\.9693\.8692\.4293\.52DROP87\.7085\.9279\.0662\.8282\.08BBH86\.5968\.7675\.8684\.7682\.28SciQ95\.4093\.4092\.4093\.8092\.50IFEval85\.5877\.0579\.2170\.0384\.72CodeMBPP96\.5090\.6680\.5478\.9989\.49MBPP\+98\.6891\.5383\.6097\.6283\.07HumanEval96\.9586\.5979\.8892\.0789\.02HumanEval\+92\.0787\.8078\.6689\.0287\.20MathAIME 2490\.1085\.0093\.3388\.3392\.09AIME 2583\.7574\.1791\.2587\.5083\.75AMC96\.7391\.8093\.5791\.0594\.21OlympiadBench81\.2076\.6888\.6470\.0380\.50

Table[3](https://arxiv.org/html/2607.16051#S4.T3)highlights the pre\-training efficiency of Loopie\-20B\-A2B\. Loopie is pre\-trained on only 3\.5T tokens, whereas Nemotron 3 Nano and Nemotron Cascade 2 are each trained on 25T tokens drawn from the same pre\-training data source\. Thus, Loopie uses less than one seventh of their pre\-training tokens, yet matches or outperforms both models on most knowledge and general\-capability benchmarks\. In particular, Loopie reaches 81\.28 on MMLU, exceeding both Nemotron 3 Nano \(80\.52\) and Nemotron Cascade 2 \(81\.22\)\. On ARC\-Challenge, Loopie scores 93\.52, outperforming Nemotron 3 Nano by 1\.56 points and coming within 0\.34 points of Nemotron Cascade 2\. It also substantially surpasses both models on BBH, with a score of 82\.28 versus 68\.76 and 75\.86, and on IFEval, with 84\.72 versus 77\.05 and 79\.21\.

This advantage extends across the broader pre\-training evaluation suite: Loopie exceeds at least one of the two Nemotron models on every reported knowledge or general\-capability benchmark and outperforms each of them on five of the seven benchmarks, despite having a pre\-training token budget more than seven times smaller\. The resulting profile is therefore not merely competitive at a smaller training budget; it indicates substantially higher token efficiency under the same pre\-training data\. Loopie also retains strong post\-training reasoning performance, reaching 92\.09 on AIME 2024 and 94\.21 on AMC, ranking second among the listed models on both benchmarks, while its AIME 2025 score of 83\.75 ties Qwen3\-30B\-A3B Thinking\.

DeepSeek\-R1Distill\-Qwen1\.5BGemma\-4E2B\-itGemma\-4E4B\-itQwen31\.7BMiniCPM51BOuro 1\.4BThinkingOuro 2\.6BThinkingLoopie6B\-A0\.6BKnowledgeMMLU44\.8563\.3372\.9769\.0861\.5472\.4082\.7078\.36MMLU\-Redux51\.2872\.2879\.6174\.2870\.6373\.7586\.2881\.35GeneralARC\-Easy69\.1987\.0892\.9791\.2085\.2790\.8794\.2893\.77ARC\-Challenge61\.0983\.2890\.0286\.0975\.3488\.4893\.9491\.13SciQ44\.1086\.8094\.4087\.7082\.4891\.6094\.9090\.10CodeMBPP35\.8077\.0482\.4980\.5450\.9788\.6395\.6976\.65MBPP\+63\.7686\.7790\.2182\.8081\.7589\.8996\.0184\.66HumanEval65\.8579\.2791\.4685\.9886\.5995\.1295\.1284\.15HumanEval\+65\.2481\.7185\.9882\.9386\.5987\.8089\.0279\.88MathAIME 2435\.8338\.3349\.1749\.5847\.5050\.8362\.5080\.42AIME 2524\.1726\.2535\.4235\.0038\.7544\.1751\.6770\.83AMC67\.9175\.3785\.0873\.8828\.3678\.3685\.8284\.33MATH\-50083\.6089\.0091\.6090\.6060\.0092\.2092\.2093\.80GSM8K72\.1890\.6093\.4090\.1476\.3594\.0996\.1393\.63

## 5Related Work

### 5\.1Looped Transformers

We use the term*looped model*to denote an architecture that reuses a learned internal operator within a single forward computation, rather than repeatedly calling an otherwise complete model\. This design lineage predates contemporary language models: Neural GPUs repeatedly apply a shared convolutional transition to learn algorithms, Adaptive Computation Time \(ACT\) learns how many recurrent updates to execute, Universal Transformers \(UTs\) tie self\-attention and transition blocks across depth, and Deep Equilibrium Models \(DEQs\) avoid explicit unrolling by solving for a fixed point of a weight\-tied transformation\(kaiser2016neural;graves2016adaptive;dehghani2018universal;bai2019deep;bai2020multiscale\)\. Work on training implicit models and on generalist neural algorithmic learners further established practical optimization methods and reusable processors for effectively unbounded or task\-shared computation\. These are direct architectural antecedents of looped Transformers, not merely generic recurrent or test\-time\-compute methods\.

Across Transformer families, layer tying, recurrent state, adaptive depth, and memory reuse also appear in ALBERT, tied Transformers, depth\-adaptive Transformers, feedback memory, recurrent\-memory Transformers, and block\-recurrent Transformers\(lan2019albert;xia2019tied;elbayad2020depth;fan2020feedback;bulatov2022rmt;hutchins2022blockrecurrent\)\. Modern variants make the shared\-depth computation itself the central scaling axis\. MoEUT recurrently reuses fine\-grained expert groups, Relaxed Recursive Transformers supplement a repeated block with depth\-specific low\-rank adapters, and implicit state\-space language models iterate a shared transition toward a fixed point while preserving substantial training parallelism\(csordas2024moeut\)\. Thus, rather than relying on ordinary depth scaling, looped Transformers learn a reusable transitionht\+1=Fθ​\(ht,x,et\)h\_\{t\+1\}=F\_\{\\theta\}\(h\_\{t\},x,e\_\{t\}\), whereete\_\{t\}may encode the loop index, a halting state, or an injected copy of the input\. Effective inference depth can then vary without introducing an independently parameterized layer at every step\.

### 5\.2Inductive Biases

Looped depth imposes several biases that are weak or absent in a stack of independent Transformer layers\.*First, recurrent operator sharing*encourages a reusable update rule rather than a sequence of layer\-specific feature maps\. This is the defining recursive bias of UTs and tied\-depth models, and theoretical analyses connect it to fixed\-point iteration, gradient\-based in\-context learning, normalized gradient descent, and power iteration\(dehghani2018universal;takase2023lessons;yang2023looped;gatmiry2024can;chen2025bypassing;wu2026powermethod\)\.*Second, shared depth decouples effective computation from parameter count*: a compact recurrent core can be unrolled for more steps, favoring iterative refinement over memorizing a separate computation in each layer\(lan2019albert;saunshi2025latentthoughts;geiping2025scalinglatent;zhu2025scalinglatent;schwethelm2026much\)\.

*Third, looping induces an iterative\-algorithm bias*\. When a target computation is naturally expressed by repeated application of a small rule set, looped models can emulate programs, optimization procedures, graph algorithms, and structured algorithmic processors, often improving length or depth extrapolation when the loop count adapts to problem size\(giannou2023looped;backdeluca2024simulation;gao2025algoformer;fan2024looped;xu2025cotloop\)\.*Fourth, weight sharing creates a knowledge re\-access and compositionality bias*: after each new bridge entity is inferred, the same retrieval, binding, and update machinery can be applied again\. This directly targets failures of implicit multi\-hop composition in ordinary Transformers and motivates architectures that carry discrete and continuous states or align latent and explicit reasoning\(wang2024grokking;biran2024hopping;guo2025twohop;yao2025implicit;kohli2026loopthinkgeneralize;fu2026discoloop;fan2026lotus\)\.*Fifth, recurrence provides a latent scratchpad and an adaptive\-computation bias*\. Additional computation occurs in the hidden state rather than through the generation of extra verbal tokens, while timestep conditioning, token\-wise routing, dynamic halting, fixed\-point convergence, and shortcut consistency allocate more computation to harder inputs\(saunshi2025latentthoughts;geiping2025scalinglatent;bay2025mixture;fu2025thinkathard;jeddi2026loopformer;movahedi2026fixedpoint\)\. These benefits are not automatic: looped models can drift, overthink, or collapse to shallow computation unless their state injection, normalization, supervision, and stopping rules are designed for stable iteration\(chowdhury2024investigating;labovich2026stability;rauba2026tarm;moosa2026dynamiccompute\)\.

### 5\.3Theory, Mechanisms, and Scaling

Formal results characterize both the capabilities and the limits of shared\-depth computation\. Looped Transformers can execute instruction\-level programs, simulate latent chains of thought, and achieve better approximation rates through timestep modulation\(giannou2023looped;saunshi2025latentthoughts;xu2025expressive\)\. More specialized analyses show that a recurrently reused attention layer can learn normalized\-gradient updates for in\-context logistic regression or implement the power method under layer normalization\(wu2026powermethod\)\. At the same time, compressed recurrent states create a memory\-budget separation relative to full sequence\-state chain\-of\-thought methods, and set\-valued or graph computations require careful distinctions among fixed points, convergence, and halting\. A complementary reinforcement\-learning analysis formalizes how additional internal computation changes the class of compute\-bounded policies\.

A second line of work studies optimization, stability, and scaling with loop count\. Fixed\-point analyses identify conditions under which recurrent states remain reachable, input\-dependent, and trainable; residual\-scaling theory argues that correlated tied\-block updates require loop\-aware scaling; and iso\-depth studies quantify the exchange rate among recurrent passes, unique depth, and training compute\(labovich2026stability;wang2026residualscaling;schwethelm2026much\)\. Two\-scale latent\-dynamics analyses derive convergence\-sensitive early\-exit criteria, while controlled studies of adaptive computation show that learned loop allocation can correlate with token difficulty without necessarily extrapolating to longer inputs\(pappone2025twoscale;moosa2026dynamiccompute\)\. Memory tokens and ACT initialization can determine whether a UT enters a non\-trivial reasoning regime, and hierarchical and flat recurrence can exhibit materially different optimization behavior even under shared\-weight controls\(sapunov2026utm;han2026hierarchicalflat\)\. Compression studies likewise show that preserving per\-cell accuracy or local states is insufficient if quantization or pruning damages the recursive trajectory needed for exact solutions\.

Mechanistic work examines what is represented across recurrent steps\. Probing studies find that recurrent language models often approach loop\-specific fixed points or replay feed\-forward\-like inference stages, while evidence for a literal latent chain\-of\-thought is mixed and depth\-dependent\(blayney2026mechanistic;lu2025latentcot\)\. Shared recurrent modules can nevertheless specialize to perform distinct functional roles through asymmetric state identities, and interaction\-locality measurements reveal how repeated local updates accumulate into global puzzle structure\. Other probes recover relational preference information from differences between loop states, and analyses of tabular foundation models use the observed layer redundancy to motivate a single repeatedly applied layer\. Finally, recurrent\-depth models can unlock systematic multi\-hop generalization, but autoregressive controls show that the benefit depends on where compute is placed rather than on recursion alone\(kohli2026loopthinkgeneralize;rauba2026tarm\)\.

### 5\.4Architectures, Training Objectives, and Inference

Recent looped language models treat recurrence as a third scaling axis alongside parameter count and token count\. Huginn and Ouro pretrain recurrent\-depth language models whose shared cores can be unrolled for variable test\-time depth, while retrofitted recurrence and LoopUS convert pretrained feed\-forward models into latent\-refinement systems without training a recurrent model entirely from scratch\(geiping2025scalinglatent;zhu2025scalinglatent;mcleish2025retrofitted;park2026loopus\)\. HRM\-Text and CHERRY explore recurrent compression of deep language models, Hyperloop repeats only a middle block with cross\-loop connections, and LoopMoE, sparse looped layers, and universal expert pools combine iterative depth with conditional capacity\(wang2026hrmtext;kwon2026cherry;zeitoun2026hyperloop;chen2026loopmoe;lee2026sparse\)\. MoEUT and Relaxed Recursive Transformers provide earlier expert\-routing and low\-rank mechanisms for recovering expressivity under parameter sharing\(csordas2024moeut\)\.

Dynamic\-depth architectures decide not only*how*to update a state but also*where*and*for how long*to recur\. Mixture\-of\-Recursions routes tokens to different depths; CoTFormer exposes earlier recurrent representations and learns a compute\-budgeted router; AdaPonderLM and Think\-at\-Hard allocate extra latent iterations selectively; and Chain\-of\-Layers methods skip or repeat pretrained layers at test time\(bay2025mixture;mohtashami2025cotformer;fu2025thinkathard;li2026programlayers\)\. LoopFormer regularizes trajectories across sampled depths, adaptive\-loop models couple halting with external memory, and ChainGPT, MoDr, and depth\-recurrent attention mixtures enrich the recurrent state transition through multi\-rank updates, branch routing, or mixtures of sequence and depth attention\(jeddi2026loopformer;frey2026adaptive;zheng2026chaingpt;zhang2026modr\)\. SpiralFormer instead changes the resolution schedule across repeated applications, and subgoal\-persistence models study when a hierarchical reasoner should re\-plan rather than update the same latent plan at every step\(yu2026spiralformer;chadha2026replan\)\.

A parallel line of work targets stable and efficient unrolling\. Parallel Loop Transformers share representations across loops, and LT2 replaces quadratic attention with a linear\-time looped design\(wu2025parallellooptransformerefficient;deng2026lt2\)\. MELT keeps cache memory independent of loop depth; LASER compresses recursive activations during training; and Hyperloop and CHERRY reduce the number of distinct parameter blocks\(cakar2026laser;zeitoun2026hyperloop;kwon2026cherry\)\. Parcae constrains recurrent dynamics and derives scaling laws, CART anchors each iteration to context, fully looped signal routing stabilizes high loop counts, stochastic stopping improves extrapolation across unseen depths, and stability\-aware recurrent training reduces drift under test\-time scaling\(prairie2026parcae;capps2026cart;fu2026fullylooped;kuo2026stochasticstopping\)\. Training\-free looping explores whether a pretrained model can be recurrently reused without architectural retraining\(chen2026trainingfree\)\.

Several methods supervise the*trajectory*rather than the final answer alone\. LoopRPT applies reinforcement pre\-training across latent iterations, RLTT distributes reward over the latent trajectory, denoising recursion trains models to repeatedly correct corrupted targets, and Generative Recursive Reasoning expands recurrence into stochastic multi\-trajectory generation\(tang2026looprpt;cameron2026denoisingrecursion;baek2026gram\)\. Probabilistic TRM injects noise at inference and selects among recursive trajectories, whereas LoopFormer uses shortcut consistency to align different computation budgets\(sghaier2026ptrm;jeddi2026loopformer\)\. Looped diffusion language models, fixed\-point masked generative models, equilibrium reasoners, and attractor models connect explicit recurrence to denoising or convergence\-based generation\(miele2026fixedpointmasked;feinashley2026attractor\)\. These approaches make intermediate\-state quality, convergence geometry, and trajectory diversity first\-class training targets rather than incidental by\-products of depth\.

### 5\.5In\-Context, Algorithmic, and Compositional Generalization

In\-context learning can be interpreted as executing an implicit learning algorithm over demonstrations\. Bayesian, gradient\-descent, preconditioned\-gradient, linear\-model, and causal\-structure accounts motivate studying whether each recurrent step implements one additional internal update\(xie2022explanation;akyurek2023learning;vonoswald2023transformers;ahn2023transformers;li2023algorithms;zhang2023trained;nichani2024causal\)\. Looped Transformers make this correspondence explicit: they learn data\-fitting algorithms with substantially fewer unique parameters, implement multi\-step gradient procedures, and can use distinct preprocessing, looping, and postprocessing stages\(yang2023looped;gatmiry2024can;chen2025bypassing;gao2025algoformer\)\. Program\-simulation results and normalized\-gradient analyses further connect shared depth to reusable algorithmic primitives\(giannou2023looped\)\.

The same prior is relevant to length and compositional extrapolation\. Neural GPUs and generalist recurrent processors learn repeated algorithmic updates, while looped Transformers simulate graph algorithms and obtain strong length generalization when the number of recurrent steps grows with the instance\(kaiser2016neural;backdeluca2024simulation;fan2024looped\)\. Timestep modulation, multi\-resolution recursion, and depth\-recurrent compositional models address the failure of a single stationary update to remain useful far beyond the trained depth\(xu2025expressive;yu2026spiralformer;chen2026thinking\)\. DiscoLoop carries both discrete embeddings and continuous hidden states across hops, and LOTUS aligns recurrent latent blocks with explicit chain\-of\-thought computation\(fu2026discoloop;fan2026lotus\)\. These results complement evidence that ordinary Transformers often memorize local facts or short computations yet fail to compose them systematically out of distribution\(biran2024hopping;yao2025implicit;dziri2023faith\)\.

### 5\.6Abstract Reasoning

ARC\-style tasks are a natural stress test because they require inducing a new transformation from a few demonstrations rather than recalling a fixed skill\(chollet2019measure;chollet2025arcagi2\)\. HRM obtains substantial effective depth through coupled high\- and low\-level recurrent modules, TRM reduces the design to a tiny repeatedly applied network, and the URM study attributes much of the gain to Universal\-Transformer\-style recurrence and nonlinear depth computation\(wang2025hierarchical;jolicoeurmartineau2025trm;gao2025universal\)\. Controlled analyses caution that hierarchy, augmentation, identity conditioning, majority voting, and competition\-time adaptation can materially affect reported scores\(ge2025hrmperspectives;ren2026reasoningguessing;royeazar2025trm;mcgovern2025testtime\)\.

Follow\-up designs explore complementary ways to improve recursive abstract reasoning\. CosmicFish\-HRM adapts hierarchical recurrence to compact language models; Recursive Inference Machines generalize generator–solver recursion; and Fixed\-Point Reasoners halt upon convergence rather than at a preset depth\(lakkapragada2026cosmicfish;komisarczyk2026rim;movahedi2026fixedpoint\)\. Generative, probabilistic, and denoising recursive models introduce trajectory diversity or iterative corruption\-and\-repair curricula\(baek2026gram;sghaier2026ptrm;cameron2026denoisingrecursion\)\. Equilibrium and attractor reasoners learn convergent solution dynamics, whereas Tiny Autoregressive Recursive Models test whether comparable compute is better spent on recurrence or ordinary autoregressive depth\(feinashley2026attractor;rauba2026tarm\)\. Memory\-augmented UTs, LoopViT, and interaction\-locality analyses expose complementary depth–state, visual\-recurrence, and mechanism\-level views\(sapunov2026utm;shu2026loopvit\)\. Overall, this literature supports recurrence as an architectural prior for iterative abstraction, while showing that successful test\-time scaling depends on stable state transitions and informative intermediate supervision rather than loop count alone\(chollet2026arcprize;vahdati2026arcprogress\)\.

## 6Future Work

Due to computational constraints, our post\-training experiments focus primarily on mathematical and code reasoning tasks\. We do not extensively explore other important capabilities studied in prior work, such as scientific question answering, instruction following, alignment with human conversational preferences, or agentic task\-solving\. A natural direction for future work is to continue to post\-train Loopie on a broader set of tasks and preference signals, which may further improve its practical utility and general\-purpose capabilities\. Also, due to limited computational resources, we were unable to conduct a sufficiently comprehensive ablation study of supervised pre\-training, which we leave for future work\.

In addition, our study focuses primarily on matching compute budgets during pre\-training, and we have not yet conducted systematic studies of inference\-time computation\. Matching and optimizing inference\-time compute remain important directions for future work; prior work such as the Parallel Loop Transformer\(wu2025parallellooptransformerefficient\)provides a promising example of this approach\.

Finally, our study intentionally focuses on applying looped Transformers to a relatively clean and well\-controlled base architecture, Qwen3\-30B\-A3B, in order to avoid confounding factors introduced by architectural variations\. As a result, we do not investigate several recent architectural advances that may be complementary to our method\. Exploring how Loopie interacts with these newer designs remains an important direction for future work\.

## 7Conclusion

We introduced Loopie, a family of looped MoE language models that makes recurrent depth competitive under a matched pre\-training compute budget\. By combining layer\-loop recurrence with a hardware\-aware scaling recipe, Loopie consistently outperforms compute\-matched vanilla Transformer baselines across model scales\. A large\-scale post\-training pipeline based on Supervised Pre\-training and reinforcement learning further equips Loopie with strong mathematical reasoning and coding abilities\. These results suggest that recurrent computation, when jointly optimized with architecture and training efficiency, can serve as a practical scaling axis for large language models\.

## Author Contributions

Zitian Gao completed model training, experimental implementation, and writing of this paper\. The model architecture was designed by Zitian Gao, Yilong Chen, Yihao Xiao, and Xinyu Yang, with guidance from Ran Tao, Joey Zhou, and Bryan Dai\. Yilong Chen and Xinyu Yang completed this work during their internship at IQuest Research\.

## 8Acknowledgments

- •We thank Benhao Huang at Carnegie Mellon University and Shaowen Wang at Tsinghua University for their valuable feedback and careful review\.
- •We thank Zhengmao Ye at IQuest Research for his infrastructure support\.
- •We thank NVIDIA Nemotron for its outstanding contributions to the open\-source community\. In particular, Loopies would not have achieved its current level of performance without the training data provided by Nemotron\-CC\-v2 and Nemotron\-Cascade\-2\.
- •We thank the Allen Institute for AI \(AI2\) for the elegantLaTeXtemplate used in this work\.

## References

## A Architecture Details

Table 4:Architecture Details of Loopie\-20B\-A2B and Loopie\-6B\-A0\.6BLoopie\-20B\-A2BLoopie\-6B\-A0\.6BLayer\-loop times22QK layer normEnabledEnabledNum layers2718Hidden size23041536MoE hidden size832576Attention typeGQAGQAAttention heads7248Attention groups3624Position embedding typeRoPERoPERotary base1000010000RMSNorm eps1e\-61e\-6MoE router topk88Num experts128128MLP typeSwiGLUSwiGLUTokenizerQwen3Qwen3Vocabulary size151936151936
## B Pre\-training Details

Table 5:Pre\-training Stage\-1 Details of Loopie\-20B\-A2B and Loopie\-6B\-A0\.6BLoopie\-20B\-A2BLoopie\-6B\-A0\.6BInitialization std1/2\.5∗23041/\\sqrt\{2\.5\*2304\}1/2\.5∗15361/\\sqrt\{2\.5\*1536\}LM head Initialization std1/23041/\\sqrt\{2304\}1/15361/\\sqrt\{1536\}Embedding Initialization std1/23041/\\sqrt\{2304\}1/15361/\\sqrt\{1536\}MoE Auxiliary loss coeffient0\.010\.01Learning rate310−43\\times 10^\{\-4\}510−45\\times 10^\{\-4\}Learning rate scheduleWarmup\-then\-stableWarmup\-then\-stableWarmup steps60002000Global batch size10241024Sequence length81928192OptimizerAdamWAdamWβ1\\beta\_\{1\}0\.90\.9β2\\beta\_\{2\}0\.950\.95Weight decay0\.10\.1Clip gradient1\.01\.0Adam epsilon110−151\\times 10^\{\-15\}110−151\\times 10^\{\-15\}Table 6:Pre\-training Stage\-2 Details of Loopie\-20B\-A2B and Loopie\-6B\-A0\.6BLoopie\-20B\-A2BLoopie\-6B\-A0\.6BLearning rate310−43\\times 10^\{\-4\}510−45\\times 10^\{\-4\}Learning rate scheduleConstantConstantMoE Auxiliary loss coeffient0\.010\.01Global batch size10241024Sequence length81928192OptimizerAdamWAdamWβ1\\beta\_\{1\}0\.90\.9β2\\beta\_\{2\}0\.950\.95Weight decay0\.10\.1Clip gradient1\.01\.0Adam epsilon110−151\\times 10^\{\-15\}110−151\\times 10^\{\-15\}
## C Scaling Ladder Details

RungModelTotalParamsActiveParamsLLDDDMoED\_\{\\mathrm\{MoE\}\}HeadsHeadDimNNWidth/DepthTokens1Vanilla1\.34B0\.15B276401922032123\.70150BLoopie1\.08B0\.11B157042562232223\.47150B2Vanilla2\.37B0\.25B307682562432125\.60250BLoopie1\.81B0\.18B178323202632224\.47250B3Vanilla4\.76B0\.51B3612803203240135\.56500BLoopie3\.78B0\.41B1912803843240233\.68500B4Vanilla9\.14B1\.00B4612803844032127\.83500BLoopie6\.36B0\.68B2514084484432228\.16500B

Table 7:Architecture details for the Loopie scaling ladder\. Each Loopie model is paired with a non\-recurrent vanilla MoE baseline under matched pre\-training wall time\. HereDDdenotes hidden dimension,DMoED\_\{\\mathrm\{MoE\}\}denotes each expert’s hidden size,LLdenotes the number of stored Transformer/MoE layers, Heads denotes the number of attention heads, Head Dim denotes the dimension of each attention head,NNdenotes the number of recurrent layer\-loop steps, and Width/Depth denotesD/\(L​N\)D/\(LN\)\.
## D Supervised Pre\-training Details

Table 8:Training hyperparameters for Loopie\-20B\-A2B and Loopie\-6B\-A0\.6B in Supervised Pre\-training\.Loopie\-20B\-A2BLoopie\-6B\-A0\.6BGlobal batch size10241024Sequence length131072131072Learning rate110−51\\times 10^\{\-5\}110−51\\times 10^\{\-5\}Learning rate scheduleWarmup\-then\-stableWarmup\-then\-stableWarmup steps500500MoE Auxiliary loss coeffient0\.010\.01OptimizerAdamWAdamWβ1\\beta\_\{1\}0\.90\.9β2\\beta\_\{2\}0\.950\.95Weight decay0\.10\.1Clip gradient1\.01\.0Adam epsilon110−151\\times 10^\{\-15\}110−151\\times 10^\{\-15\}

Similar Articles

Loop the Loopies!

arXiv cs.CL

Loopie is a new looped Transformer model that achieves gold-medal performance at the 2025 IMO and IPhO without external tools, using a novel post-training pipeline. It outperforms vanilla Transformers trained with the same compute budget.

Multilingual-Multimodal-NLP/LoopCoder-V2 · Hugging Face

Reddit r/LocalLLaMA

LoopCoder-V2 is a 7B instruction-tuned code model built on the Parallel Loop Transformer (PLT), demonstrating non-monotonic test-time scaling with two loops providing the best gain-cost trade-off and significant improvements over baselines on code generation and reasoning benchmarks.