Letting an AI re-run the same layers twice helps, but a third pass makes it worse. Why?
Do multiple loops keep improving model performance or hit diminishing returns?
This explores looped language models, which re-run the same layers several times instead of stacking new ones, and whether each extra pass keeps paying off or flattens out.
This explores looped language models, which re-run the same layers several times instead of stacking new ones, and whether each extra pass keeps paying off. The one direct test in the collection says it doesn't. LoopCoder-v2 gets broad gains from two loops over its baseline, but three or more loops regress. The second loop does the productive refinement. Later loops oscillate and lose diversity in their internal representations, rather than converging on anything better Does adding more loops always improve looped language models?.
That result is a sweet spot, not a verdict against looping. The wider looped-model work finds that re-applying layers can beat larger feedforward networks on reasoning, because recursion helps with state tracking and compositional generalization in ways parameter scaling alone doesn't. That same work points to convergence signals as a natural place to stop Can models learn by looping instead of growing larger?. So the useful question may be when to stop for each input, not how many loops to run in total. LoopWM takes this view, spending more iterations on harder prediction steps and using spectral-norm constraints for formal stability guarantees Can looped computation replace parameter count in world models?. The corpus doesn't test whether such constraints prevent the oscillation seen past two loops, but they target the same kind of drift.
Loops also aren't a free lunch on their own. Loopie beats compute-matched vanilla Transformers only when recurrence is co-designed with hardware-aware scaling and training efficiency Can looped models beat parameter-matched standard Transformers?. Part of what looks like a loop-count effect may really be a training-recipe effect.
The same pattern shows up outside looped architectures. Once single-model pretraining saturates, a diverse population of models reaches lower validation loss than further refining one model Should extra compute refine one model or build many?. Repeated sampling from weak models widens coverage but can't choose the right answer without an outside check such as tests, proofs, or type checks When can weak models match strong model performance?. In self-training loops, step-level critique keeps solutions from narrowing too early Do critique models improve diversity during training itself?. In each case, repeating the same process loses diversity, and returns come back only when something new enters the loop: a different model, a verifier, or a critic.
Sources 7 notes
LoopCoder-v2 shows that two loops deliver broad gains over baseline, but three or more loops regress. Loop 2 carries the productive refinement; later loops oscillate with reduced representational diversity rather than converging toward better performance.
Models that re-apply layers in recurrent depth outperform larger feedforward networks on reasoning tasks. This works because recursion enables state tracking and compositional generalization that parameter scaling alone cannot achieve, with convergence signals providing natural halting.
LoopWM achieves up to 100x parameter efficiency by refining latent environment states through iterative computation in a shared block, with spectral-norm constraints providing formal stability guarantees. The approach mirrors physical system recurrence, spending more depth on harder prediction steps.
Loopie, a pair of MoE models with layer-loop recurrence, reportedly beats standard Transformers trained on the same pre-training compute budget. The win depends on co-designing recurrence with hardware-aware scaling and training efficiency, not recurrence alone.
Once single-model pretraining saturates, aggregating predictions from a diverse population of models reaches lower validation loss than further refining one model. Anti-correlated learning-rate and weight-decay schedules plus chain distillation enable this efficiently, matching 256-epoch ensembles with ~56 epochs.
Show all 7 sources
Sampling alone amplifies coverage but cannot select correct solutions. Reliable performance matching requires external soundness signals—tests, proofs, or type checks—that convert latent correct proposals into actual selections.
Step-level critique in the training loop counteracts tail narrowing and maintains solution diversity across self-training iterations. This training-time benefit—preventing premature convergence—is more fundamental than test-time accuracy gains.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Loop the Loopies!
- A Mechanistic Analysis of Looped Reasoning Language Models
- Can Looped Transformers Learn to Implement Multi-step Gradient Descent for In-context Learning?
- LoopCoder-v2: Only Loop Once for Efficient Test-Time Computation Scaling
- Scaling Latent Reasoning via Looped Language Models
- Looped World Models
- Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach
- Loop, Think, & Generalize: Implicit Reasoning in Recurrent-Depth Transformers