Recent discussion of recurrent-depth/looped transformers (especially in the context of OpenAI's Astra model) has mostly focused on the number of recurrent passes per token. The usual reassurance is that if this number is small, the model only gains a bounded amount of opaque computation before it must emit another readable CoT token.

I think this may miss an important distinction: some recurrent KV-cache policies can create cross-token paths from later recurrent depths back to earlier recurrent depths.

The Huginn recurrent-depth paper^[1] describes a bounded-cache scheme in which, at recurrence , the model reads and writes cache slot . It also states:

By attending to the output of later steps of previous tokens in the early steps of current tokens, as described in the KV-cache sharing section, we actually construct a computation that is deeper than the current number of recurrence steps.

Suppose the maximum recurrence is 10 and the cache budget is 5. Recurrence 6 then overwrites the slot associated with recurrence 1. If recurrence 1 of token attends to the resulting K/V state of token , there is a causal path like:

Thus, although each token receives at most 10 recurrent passes, the opaque serial depth^[2] of the computation can grow with sequence length. Tokens are still required to provide space for long reasoning, but the reasoning itself does not have to pass through the CoT. The CoT tokens could be arbitrary filler, while the true reasoning happens in the shared KV-cache.

This seems directly relevant to the argument in Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety^[3], which says:

Chain of thought is the only way that information can flow down from later to earlier layers.

That claim appears true for ordinary feed-forward transformers, but not necessarily for recurrent-depth models using modulo cache sharing, “deepest available” KV lookup, or similar cross-depth cache sharing. In such models, limiting the recurrence count per token may not bound opaque serial depth over a whole rollout.

Public reassurance about Astra has referred to the bounded “depth of the computation graph” without disclosing the cache topology or clarifying whether depth is measured per token or over an entire generated trajectory. As such, this does not actually exclude unlimited opaque serial depth.

Update: Inspired by Rohan Subramani's post, I ran an experiment that I've dubbed LatentMathBench^[4]. I randomly generated tasks requiring long chains of multi-step calculations, such as:

The task is structured in such a way that a model with the architecture described above could theoretically do the calculations in the opaque serial path of a recurrent block. I used Rohan's system prompt to suppress reasoning and verified the number of reasoning tokens used was zero for each test so I could invalidate responses that did use reasoning (Astra never did, and all others except GPT-5 had the option to disable reasoning).

(I tried the same with Fable 5/5.1 but the requests were blocked^[5])

Astra is clearly an outlier here. The 50% success horizon for GPT-6 Astra is roughly 4x higher than the next best model (GPT-5.6 Sol), and 7x higher than GPT-4. That by itself doesn't prove anything, but it is surprising, given that Jakub Pachocki (OpenAI) stated^[6]:

The depth of the computation graph for our present frontier models, including Astra, is within a factor of two of GPT-4.

At the very least, these results demonstrate that “depth of the computation graph” (however OpenAI defines this) is not a good proxy for sequential reasoning ability without CoT.

Disclosure: I used AI to write parts of this post since I am not a native English speaker.

1. ^{^}

   https://arxiv.org/abs/2502.05171, especially sections 6.1-6.3, and its KV-cache sharing reference implementation.

2. ^{^}

   https://arxiv.org/abs/2603.09786

3. ^{^}

   https://arxiv.org/abs/2507.11473

4. ^{^}

   https://github.com/MaartenBaert/LatentMathBench

5. ^{^}

   “This request was blocked as it seems to violate Anthropic's Terms of Service restrictions on reverse engineering or duplicating model outputs.”

6. ^{^}

   https://x.com/merettm/status/2095023204993490967