There have been two reliable ways to make a language model think better. You can make it bigger, adding parameters. Or you can let it write before it answers, adding tokens. Both work, and both are expensive: the first costs memory, and the second costs time that grows with every token written.

There is a third way, and this autumn it became the most discussed idea in AI. In September, The Information reported that OpenAI's GPT-6 Astra is a recurrent-depth, or looped, transformer [1]. A looped transformer runs some of its own layers more than once, with the same weights, before it answers. OpenAI's chief scientist later said the company had limited how far Astra's looping goes [2]. The idea is simple. The model thinks in depth instead of in tokens, and reasoning happens in latent space, inside the network, where no one can read it.

Chat models make latent reasoning hard to study, because they also reason in text, and it is hard to tell which kind of thinking produced which gain. Our decision models provide a simpler setting for studying the benefit of recurrent looping. They take a context, a question, and a fixed set of options, and return a probability for each option without generating intermediate reasoning text. By adding a recurrent loop, we can test whether repeating layers improves decision quality through additional computation in the model’s internal representations, or latent space.

This post reports what happened when we gave a decision model a recurrent loop. In brief:

1. It pushes the frontier. On the Hugging Face Decision Index, where the leaderboard's maintainers score every model themselves on test questions that model developers never see, Recurrent Looped GLiDE scores 73.37 and ranks #1 of 274 models, at 112 ms per decision. It is 1.5 points ahead of the best model of similar size, 5.4 ahead of Perplexity's 27B decision model, and above our own previous #1, GLiDE V1.2 (71.52). The loop adds no new weights. Every model in the GLiDE family sits on the size–quality frontier.

2. Latent reasoning scales with the model. Across five model sizes, the benefit of extra depth grows with scale. It is absent below 1B parameters and clearest at 27B.

3. The shape of the loop matters more than its existence. What works is narrow and specific, and it tells us something about how transformers compute.

Why this matters, for readers new to decision models: a decision model makes the many small, high-volume choices inside an AI system, such as which tool to call, where to route a request, or whether a claim is supported, where speed and calibrated confidence matter more than prose. In 2026 they became a product category of their own, with models from Perplexity, Liquid AI, OpenAI, Microsoft and dozens of startups. The Hugging Face Decision Index is the largest open comparison of them, and because its test questions are hidden and scored by its maintainers, a top rank there is hard to earn by tuning to the test. The second independent benchmark, the Artificial Analysis Decision Index, agrees: it tested the single-pass version of this model through our public API, and GLiDE is #1 there too, with the top score of 73 and the highest accuracy of all 17 decision models, 10 to 11 points above the decision models of Microsoft and OpenAI. Reaching #1 with a loop that adds no weights is direct evidence that a model can reason better at test time by thinking in latent space.

Three ways to spend compute

The third row is what makes looping attractive for decisions. A looped model adds no parameters, so memory doesn't change. Its extra cost is fixed and known in advance, so latency stays predictable. It keeps the decision in one forward pass, so the output is still a distribution you can threshold, not text you have to parse.

The idea is old: it goes back to Universal Transformers [3]. Theory has since shown that looped transformers can simulate chains of reasoning in latent space [4], and recurrent-depth language models can scale test-time compute without writing a single token [5]. The open question was practical. Could looping improve a model that was already the best in its class, without breaking the calibration and generality that put it there?

Figure 1: Recurrent Looped GLiDE. (a) The network as built, with two middle bands that loop. (b) The same computation unrolled in depth, with shared weights at every pass. (c) An illustration of latent reasoning: each pass moves the hidden state toward the answer while keeping it readable by later layers. (d) Reasoning models spend extra compute on tokens; Recurrent Looped GLiDE spends it in depth, inside one forward pass.

You can't simply teach a network to loop

The obvious approach is to add a loop and train the model to use it. We tried four versions, each giving the loop a different amount of freedom.

• A shallow loop over the top of the network. It learned only a tiny correction to the output, and its gate stayed almost shut.

• A middle loop with its own small adapter on each pass. The loop was used, but training pulled the shared weights about two points below where they started. The loop won back only 0.2.

• Two middle loops with adapters and gates. Training diverged within a few hundred steps, as hidden states on the looped path grew by orders of magnitude.

• A frozen model with a small trainable correction on top of a working loop. Training was stable and gained +0.5, which was not significant, and it failed one of our held-out checks.

The lesson is about where the signal comes from. A trainable loop on top of a strong model has very little to learn that the model doesn't already know. Meanwhile, every gradient that flows through the loop also flows through shared weights that were already near their best. Training the loop cost more than the loop added.

Loop what the network already knows

So we asked a different question: what happens if you take the finished network and run part of it twice?

There is a good reason to expect this to fail. Every layer was trained on hidden states produced by exactly one pass through the layers below it, so a second pass hands the network an input it has never seen. Two observations suggested it could work anyway.

• The middle of a transformer is a shared workspace. Middle layers of trained transformers operate in a common representation space and tolerate being repeated or reordered [6]. The first and last layers do not, because they are specialised for reading input and writing output.

• The residual stream is an iterative estimate. Each layer adds a refinement to a running representation, so running a block again is one more refinement step on the same estimate.

Together they suggest a design. Loop the middle of the network, not its ends. Make the second pass a partial step rather than a full one, so the hidden state stays in the region the later layers know how to read.

It worked. Without changing a single weight, looping two adjacent bands of middle layers, twice each, improved the model on every measure we track:

We chose the configuration from about 110 candidates on a tuning split, then confirmed it once on held-out data that played no part in the search. Choosing among that many candidates inflates tuning-split numbers, so the held-out confirmation is the number we stand behind.

The anatomy of a useful loop

What works is narrow, and the narrowness is informative.

• Middle, not ends. Looping near the output barely helped. The useful region sits well inside the network, where representations are general rather than tied to input or output.

• Stages, not one long block. One long looped block gained less than a shorter one. The same layers split into two separately looped bands gained the most. Latent reasoning seems to happen in stages, and each stage benefits from its own repeat.

• Two passes, not three. A third pass helped some tasks but cost three points on a causal-reasoning benchmark. With an untrained loop, extra iterations eventually push the state somewhere the rest of the network can't follow, which may be why OpenAI chose to limit Astra's looping.

• A sharp optimum. After choosing the configuration, we pre-registered 16 alternatives: a third band, finer splits, shifted bands, other step sizes, and other pass counts per band. All 16 were worse.

The picture that emerges is that the loop doesn't add knowledge. It gives the network more steps to bring what it already knows to bear on the decision in front of it. That is what reasoning in latent space looks like from the outside.

Scaling reasoning in latent space

If a loop refines what a network knows, its value should depend on how much the network knows. That predicts the benefit of latent depth should grow with model scale. We tested this across the whole GLiDE family:

The trend runs in one direction: below 1B parameters, extra depth does nothing measurable, and at 27B it is the difference between second place and first. Latent depth behaves less like an extra resource and more like a multiplier on the knowledge already in the weights.

The 9B makes the point most clearly. As it first came out of training, looping did nothing for it. After one more round of post-training made the base model stronger, the same loop paid off. The loop needed something worth reasoning over.

This suggests a different view of scaling. Parameters and reasoning tokens have usually been treated as separate dials. Our results suggest that latent depth is a third dial, and that it becomes more valuable as the parameter dial is turned up. If that holds, the largest models have the most to gain from thinking in latent space.

Pushing the frontier

The result is a family of decision models that sits on the size–quality frontier at every size:

All scores are official leaderboard results on hidden test sets (board data of Nov 6, 2026, 274 models). Before release we predicted each GLiDE score from a predictor fitted to 42 models with known scores; every official score landed inside the 80% interval we predicted.

Figure 2: GLiDE model family on the Hugging Face Decision Index’s Pareto frontier (data as of November 10, 2026)

Things that didn't work

• Training the loop, in four forms (see above). Each attempt stayed level, drifted, diverged, or gained too little to clear our held-out checks.

• One long looped block instead of two shorter ones. It was redundant with the shorter block and gained less.

• Three or more passes. Some tasks improved, but causal reasoning got worse.

• Folding the loop back into the weights so a single pass behaves like a looped one, then looping again. The gains didn't stack.

• Looping a small encoder. No gain at 0.4B parameters.

• Recurrence across the whole sequence. It added 25% latency for no gain.

What comes next

The most important open problem is the third pass. Today a loop is limited to the number of passes before the hidden state leaves the region the rest of the network can read. In our experiments that limit is two. A model trained from the start to expect its own recurrence would not face that limit, and could turn latent depth into a dial that scales smoothly, rather than a single step.

Decision models are a good place to pursue that. Their reasoning has nowhere to hide: no chain of thought to credit, a calibrated distribution as the output, and a score where every point of improvement shows. If latent reasoning scales, decision models are where we expect to see it first.

Recurrent Looped GLiDE and the rest of the GLiDE family are available on Hugging Face under the Fastino Community License. The scores above are the official Decision Index results.