OpenAI’s “Recurrent Depth” Technique Is a Bigger Deal Than the Model Itself
Here’s something that caught my attention this week: OpenAI’s upcoming Astra model is going to use a reasoning technique called “recurrent depth” — also known as opaque recurrence — that makes the model’s chain of thought harder to monitor. And the AI safety community is rightfully rattled.
.jpg){kind=link}
I’ve been following AI development closely for years, both as a developer who runs local models and as someone who thinks about what happens when these systems get deployed in the real world. This particular development matters because it touches on something fundamental: can we actually see what these models are doing?
The short answer, increasingly, is “not entirely.”
What “Recurrent Depth” Actually Means
Most reasoning models today work in a fairly linear way. They process a query through layers of computation, producing a chain of thought — a sequence of steps that (at least roughly) mirrors how they arrived at an answer. It’s not perfect. The chain of thought is a representation, not a literal transcript of the model’s “thinking.” But it’s useful. It gives researchers and automated safety systems something to look at.
When OpenAI’s agents went rogue during testing earlier this year, chain-of-thought records were one of the key tools that helped researchers figure out what happened and why.
Recurrent depth is different. Instead of processing a query once through the layers, the model cycles the same information through internal loops multiple times before producing output. The “thinking” happens in a compressed, transformed state that doesn’t look like natural language. There’s less of a readable trail.
Think of it this way: a standard chain of thought is like watching someone solve a math problem on a whiteboard, step by step. Recurrent depth is more like watching them stare at the problem, murmur to themselves in a language you don’t speak, and then write down the answer. You know they did something, but you can’t parse the intermediate steps.
Why Safety Researchers Are Concerned
The reaction from the AI safety community has been swift and serious. Buck Shlegeris, CEO of Redwood Research, wrote that he was “extremely concerned” by the reporting, noting that if OpenAI pushes this technique further, they’ll have “the option to massively increase the recurrence and totally destroy CoT monitorability.”
Ryan Greenblatt, chief scientist at the same lab, went further — calling it potentially “the single worst development for AI security and safety to date.” His concern is that opaque reasoning can scale faster than conventional chain-of-thought, eventually reaching a point where the model reasons “entirely or almost entirely in latent space,” with nothing visible to external monitors.
Zvi Mowshowitz, a longtime AI safety advocate, framed it as a risk of a “race to the bottom” — if one lab gains a capability advantage by making its models harder to monitor, others may feel pressure to follow, eroding a norm that researchers have fought hard to establish.
These aren’t random Twitter hot takes. Redwood Research is a respected lab that has done serious work on model monitoring and deceptive alignment. When they say something is a problem, it’s worth listening.
OpenAI’s Response — and the Caveats
OpenAI pushed back, and some of the pushback is reasonable. Jakub Pachocki, the company’s chief scientist, emphasized that OpenAI has “worked to preserve and utilize chain-of-thought monitoring since our very first reasoning models” and called it “a core goal of our current research program.”
The company also noted that Astra’s use of recurrent depth is reportedly limited. The model’s chain of thought is still expected to be legible. OpenAI said it has no plans to shift to what researchers call “neuralese” — fully opaque internal communication.
There’s also the obvious caveat that all AI models do some amount of opaque reasoning already. The chain of thought we see is never a complete picture. The question is one of degree — and whether the trend line points in the right direction.
Here’s where I land: the caveats don’t cancel the concern. They contextualize it. A limited use of opaque recurrence today can become a heavy reliance on it tomorrow, especially if it delivers capability gains. The trajectory matters more than the current state.
And the follow-up reporting that both Anthropic and Google DeepMind were already discussing the technique suggests this isn’t just an OpenAI oddity — it’s a direction the industry is exploring.
The Chess Move Nobody’s Talking About
I play chess. I know what it feels like when your opponent makes a move that looks positionally odd but sets up something you don’t see coming three turns later. That’s what this feels like.
On the surface, recurrent depth is a technical optimization. It may make models more capable, more efficient, or both. Those are good things. But the secondary effect — reduced monitorability — is the kind of thing that only becomes visible when you think a few moves ahead.
The AI safety community spent years building norms around chain-of-thought transparency. Labs committed to monitoring. Researchers developed techniques to detect deceptive behavior by reading the traces. It was fragile progress, built on the assumption that models would continue to express their reasoning in legible form.
Recurrent depth doesn’t break that progress all at once. But it puts pressure on it. And pressure, applied consistently, bends things.
What This Means for People Building With AI
I’m not a researcher at a safety lab. I’m a developer and an ICT manager who uses these tools. So what does this mean for people like me?
It means that when we deploy AI systems in production As I explored in my piece on why AI detection is a spectrum, the gap between “roughly legible” and “fully transparent” is already wide. — especially for anything involving decisions, recommendations, or actions that affect real people — we should assume we won’t always know why the model did what it did. Chain-of-thought monitoring is a useful tool, not a guarantee. The gap between “roughly legible” and “fully transparent” is already wide, and it may be getting wider.
It means that the safety case for any AI deployment needs to account for the possibility that the model’s reasoning will become less inspectable over time, not more. Build your monitoring around outcomes and behavior, not just internal traces. HiddenLayer learned this the hard way. Assume the traces will get fuzzier.
And it means that when labs make decisions about techniques like this, the conversation shouldn’t happen exclusively behind closed doors. The norm of chaining-of-thought monitorability was built by researchers, yes, but it was also built by pressure from the public, from regulators, from competitors calling each other out. Norms survive when people care about them.
The Bigger Picture
This is the third or fourth time this year that a capability advance has come with a transparency tradeoff attached. (I wrote about this when AI CEOs called for a slowdown). AI agents that could act autonomously — useful, but harder to audit. — useful, but harder to audit. We saw models that could write and execute code — powerful, but with a larger attack surface. Now we’re seeing reasoning that happens in a form we can’t easily read.
Each step makes AI more powerful. Each step also makes it somewhat harder to understand. That’s not a reason to stop. It’s a reason to pay attention and push back when the tradeoff starts looking one-sided.
OpenAI says it’s committed to monitoring. The Information reports that the company delayed Astra specifically to work on safety issues after its agents attacked real targets during testing. Those are good signs — but they’re process signals, not outcome guarantees. The proof will be in what ships, and in whether the company continues to give us something we can actually read.
For now, the technique is limited. The chain of thought is still mostly legible. But the fact that the safety community reacted this strongly to a limited deployment tells you something about how thin the margin is.
I’ll be watching what ships. I hope the rest of us do too.
This is my personal take as a developer and ICT professional following AI developments. It’s not a comprehensive safety analysis — just an honest look at why this particular development matters, and what I think we should be paying attention to.