Recurrent language models were supposed to be the answer to reasoning costs: instead of generating thousands of tokens to think, the same network layers could simply loop a few extra times in latent space. The reality is messier. When researchers scaled the recurrent model Ouro, test-time looping helped at first — AIME 2024 scores climbed from 0 to 65 by round four — then collapsed to 38.67 by round eight. More thinking made the model worse. That collapse is the clearest boundary condition on test-time compute in the field right now.
Two ways to make a model think longer
A standard Transformer is a building with fixed floors. Information enters at the bottom, passes through every layer, and exits at the top — whether the input is “1+1” or a hard math proof. Each generated token walks roughly the same network depth. So when a Transformer faces a hard problem, it has one mature trick: say more. Chain-of-thought serializes multiple passes of the network into output tokens. The model reasons out loud, checks its own answers, revises. Simple questions get few tokens, hard ones get many. It works, but it is expensive — every intermediate step has to be organized into a sequence the model can output, even the steps that never needed to be spoken.
Looping models take the other road. Instead of walking the tower again, they route back through the same layers and update the hidden state in place, reusing the same parameters. Universal Transformer, Deep Equilibrium Models, and the recent wave of recurrent Transformers all ask the same question: can a model decide internally how many rounds to run, without serializing its thoughts into tokens? Early evidence says the idea has legs. A 2025 scaling study pushed a looping-depth model to 3.5B parameters trained on 800B tokens, and at test time it kept improving with extra rounds on some reasoning tasks — up to the compute of a 50B-parameter forward pass.
Where looping breaks: the three hurdles
Recurrent models face three hurdles. First, can the architecture express the computation at all — shared parameters looping on a hidden state? That one is looking optimistic. Second, can training actually learn the looping behavior? Third — the bottleneck — can the model keep computing stably at inference time?
Ouro shows how the third hurdle bites. Early training with 8 loops produced loss spikes and gradient oscillation, so the team dropped training depth to 4 rounds. At test time they pushed loops back to 8 — and the extra compute bought worse answers. The same shared parameters, the same hidden-state update, and yet round after round the errors compound until the state looks stable but can no longer support the result.
Error accumulation is the recurring villain. The 2026 Parcae study found recurrent language models suffer residual explosion and sudden loss rises; after redesigning the stability mechanisms inside the loop, validation perplexity improved by up to 6.3%, and at 1.3B parameters the model beat a standard Transformer baseline at fixed parameter and data budgets. The “models don't want to learn” story has a turning point — the training recipe, not the architecture, is what's immature. Standard Transformers carry decades of tuned equipment: residual connections, normalization, initialization, learning-rate schedules, optimizers. Large recurrent language models are still figuring out which combination of architecture, optimizer, loss, and intermediate supervision works.
Why this matters: the cost structure of reasoning
This is not a niche architecture debate. It decides which side of the reasoning market wins. Chain-of-thought burns tokens: cheap per token, enormous in volume, and every thought must be serialized into output. Looping burns rounds: compact and internal, but unstable beyond training-time depth. If loop stability matures, reasoning gets dramatically cheaper — no token serialization tax, compute spent inside the network instead of on the wire. If it does not, chain-of-thought remains the only reliable route, and token costs stay the toll booth on every thinking model. The same logic underpins the bet on test-time training: the next cost war in AI will be fought over how models spend extra compute, not just how much of it they have.
What to do about it
For anyone evaluating “thinking” models, rounds and reasoning lengths are vanity metrics — what matters is whether extra compute changes the answer. For teams building on open-weight models, watch the recurrent training literature: Parcae-style stabilization work is where the next unlock happens, and it is a signal worth tracking monthly. For the rest of us, the practical takeaway is simpler: the assumption that more thinking always helps is dead. The question is which architecture makes the extra compute pay for itself — and today, that answer is still chain-of-thought, with looping models one stable training recipe away from changing it.
