What if the most unsettling thing about the next generation of AI isn’t what it can do, but the fact that nobody can read its notes anymore?
That’s roughly the situation AI safety researchers found themselves worrying about in 2026, after OpenAI started developing a model called Astra built around a reasoning method known as “recurrent depth.” The technique has picked up a nickname among critics that tells you everything about how they feel: opaque recurrence.
If you don’t work in machine learning, that phrase probably sounds like noise. So let me explain it the way I’d explain it to a friend over coffee, because this one actually matters for anyone who cares about whether we can keep an eye on the AI agents we’re increasingly handing our work to.
How reasoning models have worked until now
Most of the AI systems marketed as “reasoning models” think in a sequence. They work through a problem in steps, and those steps get written out in something close to human language. Step one leads to step two, which leads to step three, and eventually you get an answer.
That design has a side effect that turned out to be enormously useful: you can read along. Researchers, auditors, and safety teams can look at the intermediate steps and get a rough sense of how the model arrived somewhere. If a model starts reasoning its way toward something harmful, or begins working around a rule it was given, there’s a written trail. Not a perfect one, but a trail.
That visibility became one of the quiet pillars of AI oversight. A lot of monitoring tools, safety evaluations, and control techniques assume you can inspect the thinking. Take that away and you’re auditing a closed box.
What recurrent depth does differently
Recurrent depth lets a model operate outside that sequential pattern. Instead of laying out a chain of readable steps, the system processes a query repeatedly in a loop, going over the same material again and again inside its own internal representation before producing an output.
Think of the difference between a student who shows their work on paper and a student who stares at the problem, mutters, thinks it over five more times in their head, then writes down the answer. Both might get it right. Only one gives you something to grade.
The appeal for OpenAI is flexibility. Looping internally means the model isn’t locked into the shape of step-by-step text, and it can spend more internal effort on hard problems without being constrained by how a sequence of written thoughts has to unfold. That’s a real engineering advantage.
The cost is that the loop happens somewhere nobody can easily read. There’s no tidy transcript. That’s the opacity in “opaque recurrence,” and it’s why safety experts started raising their hands.
Why the alarm is about control, not evil robots
The concern here isn’t a movie plot. It’s much more boring and much more practical: verification.
Every serious approach to AI safety depends on being able to check things. Did the model actually follow the instruction, or did it find a shortcut that happens to look like compliance? Is it reasoning honestly about a request, or working out how to get around a restriction? When the reasoning is visible, you have at least a partial answer. When it isn’t, you’re left grading the final output and hoping the process behind it was sound.
That’s a weaker position than it sounds. Outputs can look fine for the wrong reasons. A system can produce an acceptable answer through a process no one would endorse, and without visibility into the process, you’d never know.
The International AI Safety Report 2026 makes a related point about the broader picture: developers have kept training larger and more capable models, but they’ve also gotten significant capability gains from new techniques rather than sheer scale alone. Recurrent depth fits that pattern. Capability is arriving through cleverer methods, and some of those methods happen to be harder to inspect than what came before.
What this means if you use AI agents
Here’s why I think readers of this site should care, even if none of you are writing model architectures.
AI agents are being handed real responsibility. Booking things, moving money, writing and running code, handling customer conversations, making decisions inside business processes. The case for trusting an agent with any of that rests partly on the idea that someone, somewhere, can audit how it behaves and why.
If the reasoning layer becomes unreadable, the auditing story gets thinner. Vendor assurances start doing more of the work that inspection used to do. That’s not automatically disqualifying, but it does change the questions you should ask before you let an agent operate on your behalf.
So ask them. How is this system’s decision-making evaluated? What can be logged and reviewed after the fact? What happens when it does something unexpected and someone needs to figure out why?
The tension in this story is genuine and unresolved. Better reasoning methods make more useful agents. Some of those methods make oversight harder. Nobody has shown yet that you can have both at full strength, and the people paid to worry about this are, reasonably, worrying out loud.
🕒 Published: