TL;DR: A looped transformer runs the same layer stack repeatedly. An ICLR 2025 paper proves, within its setting, that T loops can simulate T steps of chain-of-thought — the difference being that the latter leaves text at every step. Loop count has not been scaled up because training becomes unstable, and three separate efforts in 2026 are fixing that instability. Fu et al.’s abstract lists “loop count is adjustable at inference time” as an advantage. That is exactly the dial safety researchers are talking about.
In my previous piece on the Astra controversy, I made a mistake.
I cited a sequence of comparisons suggesting that larger models use fewer loops, deploying it against the Chinese-language coverage claiming loop counts would keep climbing. Those numbers came from a literature review compiled by a model inside a LessWrong post — the author explicitly noted that he had not read most of the underlying papers himself.
Later, I pulled the abstracts of all seven papers individually. Not one of those loop-count figures appeared in any of them.
To be precise: I checked the abstracts, not the full texts. The numbers may appear in the body or the appendix — I have not ruled that out. What I can say with certainty is that they do not appear in the passage each author chose to represent the paper.
And what the abstracts actually say does not support what I was originally trying to argue. Sections three and four below lay out what they do say.
This piece is the result of that re-check.
What, Exactly, Does a Looped Transformer Repeat?
The mechanism needs to be clear enough to carry everything that follows.
In a standard Transformer, information flows from the first layer to the last as each token is processed. Every layer has its own distinct weights. Forty-eight layers means forty-eight separate sets of parameters, visited once each, before the model produces the next word.
A looped transformer changes one thing: it allows a layer stack to be reused. After one full pass, the output is fed back into the same stack for a second pass — and so on, until some stopping criterion is met. The same weights are visited multiple times.
The open-source model Nanbeige 4.2 is a clean illustration. It runs a 22-layer stack twice, achieving 44 layers of effective depth, while the storage footprint remains that of 22 layers because the weights are shared. The cost is roughly twice the compute. Sebastian Raschka notes in his technical write-up that Nanbeige’s researchers found two passes to be the optimal trade-off: more passes brought almost no benefit, while making training considerably slower and more expensive.
Since reusing layers in this way is effectively equivalent to increasing model depth, “number of loops” is just another way of writing “how deep this model is.” It is depth itself, not an optional add-on.
One distinction needs to be kept clean, though, or the reasoning later will slip. Nanbeige fixed its loop count at two during training — the depth is baked in and the model runs like a 44-layer network. A different approach trains the model to operate with varying loop counts, with the number decided at inference time. Only the latter deserves to be called a dial. Both types exist. Which category Astra falls into is not publicly known.
Are Loops and Written Drafts Two Ways of Doing the Same Thing?
Saunshi et al. in their ICLR 2025 paper, “Reasoning with Latent Thoughts,” advance a fairly strong claim: many reasoning problems require depth more than they require parameter count. Their experiments show that a k-layer model looped L times performs close to a kL-layer non-looped model — and significantly better than a k-layer model run once.
The key result comes second. Within their setting, they prove that a looped model implicitly generates latent thoughts, and that T loops are sufficient to simulate T steps of chain-of-thought. They also observe that the scaling behavior of both looped and non-looped models depends on effective depth, in a pattern similar to how chain-of-thought scales at inference time.
The direction of this result matters. It says loops can simulate written drafts — not that the two are equivalent and freely interchangeable. But one direction is sufficient: when a model needs to reason through more steps, it can write intermediate thoughts as text and read them back, or it can loop through the same layer stack multiple times. The second path reaches the same places as the first.
The difference is that every step of the first path leaves behind text a human can read.
Chain-of-thought has always been monitorable not because anyone designed a monitoring system around it. It was monitorable because, for a long time, it was the only path the model had.
This is exactly what “What Is Neuralese?” was worried about. The question then was whether AI would develop a way of thinking that never gets written down. What Saunshi’s result shows is that the path was already there in the architecture.
Is Looping Worth It? That Is the Actual Debate
Chinese-language coverage described “loop counts climbing” as an established trend. The actual debate in the research literature is considerably more specific.
The abstract of the Loopie paper (“Loop the Loopies!,” July 2026) opens with the field’s long-standing problem: at equal pretraining compute, multiplying parameter count by N typically beats looping N times.
One sentence explains why nobody did this for the past decade. It was not an oversight — it was not cost-effective.
Loopie’s contribution is its claim to have resolved that problem. It consists of two Mixture-of-Experts models: 20B parameters with 2B active, and 6B with 0.6B active. At equal compute budgets, the authors report clear improvements over standard Transformer baselines, with tool-free gold-medal-level performance on the 2025 International Mathematical Olympiad and International Physics Olympiad.
Ouro (“Scaling Latent Reasoning via Looped Language Models”) points in the same direction. Models of 1.4B and 2.6B parameters, trained on 7.7T tokens, match contemporaneous models of up to 12B parameters across multiple benchmarks. The authors use ablations to attribute the gain to improved knowledge manipulation, not increased knowledge capacity.
The answer to “is looping worth it” is in the process of flipping from no to yes.
Then Why Haven’t Loop Counts Been Pushed Much Higher?
Because training breaks. This is an engineering problem, not a physical ceiling.
Fu et al. in “Simply Stabilizing the Loop via Fully Looped Transformer” diagnose the failure clearly: as loop count rises, training becomes unstable through two mechanisms, gradient oscillation and residual explosion. They propose two parameter-free fixes to address both.
DeepLoop (“Depth Scaling for Looped Transformers”) approaches the same problem from a different angle. In plain terms: when the same weights are visited repeatedly, gradients accumulate more aggressively than in a standard network, so the residuals must be suppressed more forcefully. The paper derives that, in a looped architecture, the residual scaling exponent needs to rise from one-quarter to one-half — because the same shared update is read back by the same weights in the next loop, compounding what a per-layer update would not. A separate paper, Parcae, is working on stable scaling laws for recurrent language models.
Taken together: in 2026 alone, three distinct research efforts are pushing on the same door, all targeting training stability for looped architectures.
This is a different story from “loop counts are trending downward.”
Is Loop Count Actually a Dial?
Safety researchers call it a dial. OpenAI has not directly denied the framing. But the clearest statement on the matter comes from the researchers themselves.
In the abstract of Fu et al., after describing the benefits of looped transformers, the authors add one sentence: since loop count can be adjusted at inference time, this also provides a natural mechanism for balancing performance against test-time compute.
That is written as a selling point. It describes the same thing Ryan Greenblatt identifies as concerning — a parameter currently set low that can be turned up without difficulty — just from the opposite vantage point. (Greenblatt is an AI safety researcher; the controversy arose from concerns that vendors could silently increase invisible reasoning depth without public disclosure.)
That a single architectural property is simultaneously a research advantage and a safety concern is not unusual in AI. What is unusual is that both sides are using almost identical language to describe it.
One qualification belongs here: this kind of adjustability requires that the model was trained from the start to operate at varying loop counts. A model trained at a fixed loop count will produce degraded outputs if the count is changed arbitrarily at inference time. So the dial is a training-time design choice, not a feature all looped models possess by default.
Ouro goes further still. Its training objective includes an entropy regularization term to encourage the model to learn depth allocation — in effect, a penalty that pushes the model to use fewer compute steps when possible, causing loop count to become something the model itself learns to decide based on input characteristics.
If that approach generalizes, the dial may not remain in human hands. It will be embedded in the training objective, and what an auditor would need to examine shifts from “what parameter value did you set” to “what depth strategy did your model learn.” The second question is considerably harder to answer.
Is a Looped Model Easier or Harder to Read?
This question has no settled answer yet, and it matters because the answer determines how long existing monitoring tools remain adequate.
Three lines of evidence support the “easier to read” position.
The Ouro paper itself claims that the reasoning traces produced by LoopLM align more closely with final outputs than explicit chain-of-thought does. The well-known failure mode of explicit chain-of-thought is that models say one thing and compute another. Ouro’s data suggests looped traces perform better on this dimension.
Two researchers on LessWrong who had run intermediate-state decoding experiments noted that if a model is trained to operate at variable loop counts, the intermediate state at the end of each loop must remain decodable into valid tokens — because any loop might be the last. A standard deep Transformer’s layer 37 operates under no such constraint. One of them reported self-conducted tests on Ouro-2.6B: over 95% of tokens produced identical outputs at every loop, and the tokens that did change marked precisely where the model was using additional depth. I have not independently verified this number; it comes from a comment describing personal experiments.
The opposing view carries its own weight. Recurrent architectures have higher expressive capacity than standard Transformers of equivalent depth — some operations can be learned implicitly that a standard architecture cannot represent — which makes monitoring harder. Rauno Arike’s counter was that weight tying is itself a constraint: a k-layer model looped L times is a special case of a kL-layer model, occupying a smaller function space, not a larger one.
This exchange is not resolved. But it at least establishes one thing: treating “more architectural complexity” as straightforwardly equivalent to “less transparency” is an intuition that has not been tested.
Does “We Have Limited Our Use of This Capability” Count as a Commitment?
Pulling the preceding sections together, the governance problem comes into focus.
Loop count equals depth. Depth can be adjusted at inference time. Whether scaling it up is worth it is a question the research community is in the process of answering affirmatively. And models may learn to determine their own depth allocation.
Against that backdrop, when a company says “we have limited our use of this capability,” can that sentence function as a commitment?
Geoffrey Irving offered a concrete criterion. He said he had consulted circuit complexity specialists, and their shared assessment was this: to extract a meaningful guarantee from a depth limit, you have to set it very low. If the limit is “a few hundred layers” or “we occasionally emit a token,” that is a pseudo-constraint. He drew a comparison: it is equivalent to saying “we monitor chain-of-thought” without discussing error rates. The real world is graded by numbers, not by binary claims of “we tried.”
This criterion is directly applicable in enterprise settings. Any control measure whose description contains no numbers and no error bounds is not yet something that can be audited.
Greenblatt’s three follow-up questions, posed after OpenAI Chief Scientist Jakub Pachocki responded, follow the same logic: whether there is a ready path to deploy this at much higher depth; whether the model represents an out-of-trend jump in non-visible reasoning capability; and whether the architecture introduces a depth parameter that is structurally well-suited to large-scale amplification.
All three questions are asking for a scale.
I have implemented a version of this discipline at a much smaller scale — comparable only at the level of methodology. I had a set of scheduled jobs check their own systems daily, but the ones doing real verification worked by taking a hardcoded contract file, matching it line by line against live responses, and checking whether status codes agreed — not by asking the system “are you okay?” Status codes are deterministic; the non-visible reasoning of a neural network is not, and the auditing technique cannot transfer across that gap. What does transfer is one sentence: a verification standard cannot come from the self-report of the thing being verified. That is the first principle of any audit. In AI, it has not yet been institutionalized.
A Dial Without a Scale
Here is how I read this body of work.
Looped transformers are not mysterious. The architecture is a reasonable engineering choice. Loop counts are low today because training is not yet stable enough to push them higher, not because anyone is standing guard. And the instability is being fixed by at least five separate groups simultaneously.
The reason this wave of safety-community concern is as large as it is, I think, has little to do with what Astra specifically did. It has to do with people recognizing the shape of the path: a parameter that is simultaneously a selling point and a safety concern; a depth that can be decided at training time to remain adjustable at inference time; and an oversight chain that currently relies entirely on vendor self-report.
As for who should read the scale, at what precision, and where the records should live — I said at the end of the previous piece that those three questions have no answers yet.
After re-checking seven abstracts, I have a fourth question to add: someone actually has to read what the papers say. That bar is the lowest of the four. My previous piece is where I failed it.
For more on this thread, see “Intelligence and Order → AI Governance.”
💬 Comments
Loading...