Ask OpenAI how GPT-6 Astra reasons, and the answer gets vague fast. The model solves harder problems than its predecessors, often without writing out the step by step thinking you’d expect from a reasoning model. Multiple outlets have already settled on an explanation, a technique called recurrent depth, and are reporting it as confirmed fact. It isn’t.
What OpenAI Has Actually Confirmed About Astra
- Astra launched on September 3, 2026
- It meets OpenAI’s own “Critical” cybersecurity capability threshold, the company’s highest internal risk tier
- It shows measurably reduced chain of thought monitorability compared to earlier models
- It can solve harder tasks without producing the kind of visible, verbalized reasoning trail that GPT-5.6 Sol relied on
- OpenAI has not stated what mechanism replaces that visible reasoning
That last point is the real mystery. It’s covered in more depth in our earlier look at Astra’s AGI safety debate, including a safety researcher’s direct warning about the monitorability trend. This piece focuses specifically on the mechanism itself.
The Leading Theory, and Why It’s Still Unconfirmed
Here’s how the recurrent depth claim actually spread, and why it isn’t confirmed.
- A single anonymous source told The Information that OpenAI built a limited version of recurrent depth into Astra
- Multiple outlets picked up that report and repeated it as settled fact
- OpenAI’s own system card for Astra never mentions recurrent depth
- None of OpenAI’s official launch material mentions it either
- A careful technical breakdown from Kingy AI draws this line explicitly, separating what’s confirmed from what’s reported
What this means in plain terms:
- Astra’s behavior (fewer visible reasoning tokens, lower monitorability) is compatible with recurrent depth
- Compatible is not the same as confirmed
- Other technical explanations could produce the same outward behavior
- Nobody outside OpenAI fully knows yet which one is actually true
What we can explain with confidence is what recurrent depth actually is, since it’s a real, published technique, regardless of whether Astra turns out to use it.
How Recurrent Depth Actually Works
The core research comes from a NeurIPS 2025 paper by Jonas Geiping and coauthors called Scaling up Test-Time Compute with Latent Reasoning. It describes a different way to scale up reasoning.
- Most reasoning models scale up by writing more chain of thought tokens, thinking longer in visible words before answering
- Recurrent depth scales up by looping a block of transformer layers over the input repeatedly, entirely in hidden numerical states, before producing any output
The process breaks into three stages. A Prelude turns the question into an internal representation. A Core block then loops over that representation repeatedly, often 20 to 32 times, refining it with each pass entirely in hidden numbers, never in words. A Coda takes the final looped state and turns it into the actual answer. None of the middle step happens in text. It happens in latent space, hidden numerical states that were never designed to be human readable.
What the research showed, using a proof of concept model called Huginn:
- Huginn ran at 3.5 billion parameters, trained on roughly 800 billion tokens
- Looping it about 32 times through the recurrent core pushed its ARC Challenge benchmark score from 27.99 up to 38.23
- That computation cost was roughly comparable to running a fixed 50 billion parameter model instead
- A separate model called Ouro found a real limit to this approach: 4 loops worked reliably, but 8 loops caused instability
- Performance actually dropped once a model went past the depth it was trained for
Why This Threatens Chain of Thought Monitoring
The difference between the two approaches comes down to what a safety team can actually see.
- With chain of thought reasoning, the model writes out its reasoning in plain, readable English before answering
- A safety team can read that reasoning and catch a model planning something harmful before the final answer appears
- With recurrent depth, the reasoning happens inside repeated hidden numerical states instead
- There’s nothing in that middle step for a human reviewer to read, because the reasoning was never expressed in language in the first place
That gap is exactly what safety researcher Tomek Korbak flagged as “deeply worried” about in Astra’s own launch coverage. Recurrent depth, if Astra actually uses it, would be a specific mechanical reason why that worry is justified rather than abstract.
The Confirmation Gap Nobody’s Checking
Nearly every article covering Astra’s reasoning right now states, flatly, that it uses recurrent depth. None of the ones we reviewed traced that claim back to its actual source.
Why that gap matters beyond this one story:
- It shows how quickly an unconfirmed technical claim about a frontier AI model can calcify into treated-as-fact reporting within days
- It happens simply because the claim is plausible, and nobody publishing it went back to check where it actually originated
- The same pattern showed up when outlets rushed to blame a shared Azure outage for the September 3 ChatGPT, Claude, and Grok downtime
- That theory fell apart the moment xAI’s own statement named an unrelated cause
The responsible version of this story isn’t “Astra uses recurrent depth.” It’s “a specific, real technique would explain what we’re seeing, one outlet reported OpenAI uses it based on a single source, and OpenAI itself has said nothing to confirm or deny it.”
What This Means Going Forward
- OpenAI will likely clarify this eventually, either by confirming recurrent depth directly or by staying quiet long enough that the unconfirmed version becomes the accepted story anyway
- The underlying safety question doesn’t depend on which mechanism turns out to be true
- Whether it’s recurrent depth or something else entirely, Astra is solving harder problems while producing less to monitor
- That tradeoff is the real story, not the specific technical label attached to it this week
Frequently Asked Questions
Does GPT-6 Astra actually use recurrent depth?
It’s unconfirmed. A single anonymous source told The Information that OpenAI incorporated a limited form of recurrent depth into Astra, but OpenAI’s own system card and launch materials never mention the technique.
What is recurrent depth in AI models?
Recurrent depth is a technique where a model loops the same block of transformer layers multiple times over an input before producing output, rather than writing longer chain of thought text. The looping happens in hidden numerical states, not visible words.
Why does recurrent depth make AI reasoning harder to monitor?
Because the model’s intermediate reasoning happens inside repeated hidden state passes instead of readable text, safety reviewers lose the visible trail they’d normally use to catch concerning reasoning before a model produces its final answer.
Is recurrent depth the same as chain of thought reasoning?
No. Chain of thought reasoning scales up by producing more visible text tokens. Recurrent depth scales up by looping hidden computation without producing more text, which is why it can obscure reasoning that chain of thought would normally reveal.
What is the Huginn model and why does it matter?
Huginn is a 3.5 billion parameter proof of concept model from the original recurrent depth research. Looping it about 32 times improved its performance on the ARC Challenge benchmark significantly, showing the technique can meaningfully boost reasoning without adding parameters.
Should I be worried about AI reasoning I can’t see?
It’s a legitimate concern worth watching rather than panicking over. Reduced monitorability makes it harder for safety teams to catch problems early, which is why researchers inside these labs are raising it directly rather than staying quiet about it.
