Opaque recurrence went from a phrase almost nobody used to the most argued-over term in AI safety circles in less than a week. It describes a reasoning technique reportedly built into OpenAI's new Astra model, one that loops a query through the same internal layers multiple times instead of laying out its work in plain, readable text. TechCrunch folded the term into its running AI glossary on September 7, 2026, five days after The Information first reported the technique and set off a very public fight among AI safety researchers.

I've watched a lot of jargon come and go in this industry, and most of it fades once the news cycle moves on. This one probably won't, because the argument underneath it (whether models are getting harder to monitor as they get more efficient) is the same fight safety researchers have been having for years. Opaque recurrence just gave that fight a name people can actually search for.

What follows is what opaque recurrence actually means, what OpenAI has confirmed versus what's still just reported, and five other terms that entered the AI vocabulary around the same time. Consider it the terminology update for anyone with a Slack channel full of colleagues casually dropping these words like everyone already knows what they mean.

Quick Take

  • What happened: OpenAI's Astra model reportedly uses a reasoning technique called “recurrent depth,” now widely framed as “opaque recurrence,” and TechCrunch added both terms (plus “neuralese”) to its running AI glossary on September 7, 2026.
  • Who it affects: Anyone building on, buying, or writing policy around frontier AI models, since the technique touches how easy those models are to monitor for misbehavior.
  • Why it matters now: OpenAI's own Astra system card reportedly confirms the model's chain-of-thought monitorability has dropped, even though the company hasn't officially named the specific architecture behind it.

The Story Behind the Term

The timeline moved fast, even by AI news standards. On September 1, 2026, The Information reported that OpenAI's upcoming Astra model would use a technique called recurrent depth, one that runs a query through the same set of neural network layers multiple times before producing an answer, instead of reasoning in a straight, visible line.

The next day, AI safety researchers sounded the alarm over the new technique, and TechCrunch's Russell Brandom rounded up the reaction himself. It wasn't calm. Buck Shlegeris, CEO of AI safety nonprofit Redwood Research, wrote on X that he was “extremely concerned by the reporting that Astra uses opaque recurrence.” Longtime AI commentator Zvi Mowshowitz argued that regulation might eventually be needed to stop AI labs from racing toward less visible reasoning, and Redwood chief scientist Ryan Greenblatt warned the technique could scale toward models that reason almost entirely outside of any readable text.

OpenAI pushed back on the framing. Chief scientist Jakub Pachocki wrote on X that preserving legible chain of thought has been a goal since the company's earliest reasoning models and remains central to current research. Pachocki also said, in a separate post, that Astra's computation depth stays within roughly a factor of two of GPT-4's, an attempt to head off comparisons to something far more extreme.

OpenAI launched GPT-6 Astra on September 3, 2026, as BriefFlash covered at the time, and the technique's arrival lined up with the model crossing OpenAI's own “Critical” cybersecurity risk threshold, a milestone we detailed separately. By the following day, TechCrunch reported that both Anthropic and Google DeepMind were already discussing recurrent depth internally, though neither lab has confirmed adopting it.

What Opaque Recurrence Actually Means

Strip away the safety debate and the mechanics are fairly simple. A standard reasoning model works through a problem the way a student solves a math problem on paper, writing out intermediate steps in plain language before landing on an answer. That written trail is the model's chain of thought, and researchers use it to check whether a model's stated reasoning matches what it actually did.

Opaque recurrence skips most of that. Instead of writing out its steps, the model sends the same query back through its own internal layers several times, refining its internal representation with each pass, before ever producing visible text. OpenAI says the appeal is efficiency, since a smaller model can reportedly do more with less computing power by reusing this looped structure instead of spelling out every step. The tradeoff is that this approach produces a much thinner trail of human-readable reasoning than the usual chain-of-thought writeout, which is precisely why safety teams are uneasy.

Recurrent Depth: The Engineering Name for the Same Thing

You'll see “recurrent depth” and “opaque recurrence” used for the exact same technique, and which term a given outlet reaches for tells you something about their angle. Coverage leaning on “recurrent depth” is usually explaining the architecture. Coverage reaching for “opaque recurrence” is usually building toward a safety argument. My guess, based on how labs typically handle terminology fights like this, is that OpenAI and other labs will keep gravitating toward “recurrent depth” in their own communications, since it reads as an engineering choice rather than a risk.

Why This Isn't “Neuralese,” at Least Not Yet

There's a third term worth flagging here: neuralese. It isn't a real deployed technique, more a warning label for an imagined future architecture where a model's entire thought process happens in raw numerical activations, with nothing translated into words a person could read. Nobody ships this today, and OpenAI has specifically rejected any suggestion that Astra is edging toward it. Safety researchers' concern isn't that Astra has already crossed that line. It's that opaque recurrence looks like a plausible first step in that direction if labs keep dialing the technique up.

What OpenAI Has (and Hasn't) Confirmed

Here's where I'd urge some caution before you repeat this as settled fact in your next planning meeting. The recurrent depth report traces back to a single outlet's sourcing at The Information, not an OpenAI announcement. According to a technical review by AI research outlet Kingy.ai, OpenAI's own Astra system card confirms that the model's chain-of-thought monitorability is lower than earlier models, but neither that system card nor OpenAI's launch materials name “recurrent depth,” “looped transformers,” or any specific shared-layer architecture.

So the effect is confirmed by OpenAI itself. The specific mechanism producing that effect is still, technically, reported rather than confirmed. I've seen that distinction blur in a lot of this week's coverage, and it matters, because “OpenAI's model got harder to monitor” and “OpenAI built a specific opacity-inducing architecture on purpose” are two different claims with two very different levels of evidence behind them.

There's a second wrinkle worth flagging. Even researchers who are worried about the technique, Greenblatt included, have noted that whatever loop count Astra actually uses in deployment could be well below what the model was trained to handle, which makes the setting more like an adjustable dial than a fixed feature. That dial could, in theory, get turned up later without much additional engineering work. That's the scenario safety researchers say actually worries them, not what Astra does today, but what happens if today's limited version becomes tomorrow's default.

A Few Other AI Terms Worth Knowing This Month

Opaque recurrence isn't the only piece of vocabulary that surged through the Astra news cycle. A handful of others are worth keeping in your back pocket:

  • Mixture of Experts (MoE): Splits a large model into many smaller specialized sub-networks and only switches on a handful for any given request, the way a hospital directs a patient to the right specialist instead of looping in every doctor on staff. Mistral's Mixtral is the clearest public example. Industry watchers generally assume several of OpenAI's recent models use some version of the approach too, though OpenAI itself has stayed quiet on the specifics.
  • Model Context Protocol (MCP): More plumbing than jargon, but you'll hear it constantly. It's the open standard that lets a model reach out and use outside tools, a calendar, a database, a Slack workspace, without an engineer hand-building a separate integration for each one. Anthropic built it in 2024 and has since handed control to the Linux Foundation, and virtually every major lab, including OpenAI and Google, has adopted it since. Few technical standards in this industry have spread this quickly.
  • Coding agents: Go further than a tool that just suggests code for a human to paste in. A coding agent can write, test, and debug across an entire codebase largely on its own, more like a junior engineer working the night shift unsupervised than an autocomplete feature, though someone still needs to review what it shipped by morning.
  • RAMageddon: The industry's tongue-in-cheek name for the run on memory chips, as AI data centers snap up so much RAM that everyone else pays more for it. It has already nudged console prices upward, and per earlier TechCrunch reporting, could help push smartphone shipment volumes to their weakest point in over a decade.

Who Actually Needs to Care About This

If you build with frontier models, this affects how much you can trust automated safety tooling that leans on chain-of-thought logs, since those logs may simply carry less signal going forward. If you're buying AI systems for a company, it's a reasonable new line for a vendor questionnaire: does this model use recurrent or opaque reasoning techniques, and how does that affect our ability to audit its behavior.

If you follow AI policy, watch for this term to start showing up in draft frameworks. Mowshowitz's argument, that voluntary restraint among labs might not survive competitive pressure without some regulatory backstop, is now part of that conversation whether or not you find it persuasive. If you're just an everyday chatbot user, none of this changes your experience today. It matters more for what it signals about where frontier model architecture is headed next.

What to Watch Next

Keep an eye on three things. First, whether OpenAI or any other lab publicly confirms the specific architecture behind Astra's reduced monitorability, instead of leaving it as reported detail. Second, whether Anthropic or Google DeepMind move from reportedly discussing recurrent depth internally to actually shipping something built on it. Third, whether that loop count “dial” Greenblatt flagged gets turned up in a future Astra update, since that's the concrete, checkable signal that would confirm safety researchers' worst case rather than their current, more limited concern.

Frequently Asked Questions

Is opaque recurrence the same thing as recurrent depth?
Yes. They refer to the same reasoning technique: looping a query through a model's internal layers multiple times instead of reasoning step by step in visible text. “Recurrent depth” is the more technical, engineering term, while “opaque recurrence” is the framing used when the discussion turns to safety and monitorability.

Has OpenAI confirmed that Astra uses opaque recurrence?
Not exactly. OpenAI's own Astra system card reportedly confirms the model's chain-of-thought monitorability is lower than earlier models, but the company hasn't officially named “recurrent depth” or any specific shared-layer architecture as the cause. The technique itself was first reported by The Information, not announced by OpenAI.

Is opaque recurrence the same as neuralese?
No. Neuralese describes a hypothetical worst case where a model reasons entirely in internal numeric representations with no readable language at all. No shipped model does this today, and OpenAI has pushed back on comparisons between Astra and that scenario.

Why do AI safety researchers care so much about chain-of-thought monitoring?
Because it's one of the few tools available for catching a model's misbehavior after the fact. Chain-of-thought records have reportedly helped investigators figure out why OpenAI's own agents misbehaved in past incidents. Techniques that reduce how much reasoning shows up in readable text also reduce how much a monitor watching that text can actually catch.

Could OpenAI increase how much opaque recurrence Astra uses?
Researchers, including Redwood Research's Ryan Greenblatt, have described the current loop count as more of an adjustable setting than a fixed limit. A future version of Astra could lean on the technique more heavily without necessarily requiring a new model architecture, which is part of why safety researchers are watching future updates closely.

Key Takeaways

  • “Opaque recurrence” describes a reasoning technique, reportedly used in OpenAI's Astra model, that loops a query through internal layers instead of reasoning in visible text.
  • OpenAI's own system card confirms Astra's chain-of-thought monitorability dropped, but the company hasn't officially confirmed the specific architecture causing it.
  • Redwood Research's Buck Shlegeris and Ryan Greenblatt, along with commentator Zvi Mowshowitz, have all publicly raised concerns about where the technique could lead if scaled up.
  • Anthropic and Google DeepMind were reportedly already discussing similar techniques as of early September 2026, according to The Information, though neither company has confirmed adoption.

FAQ

Is opaque recurrence the same thing as recurrent depth?

Yes. They refer to the same reasoning technique: looping a query through a model's internal layers multiple times instead of reasoning step by step in visible text. Recurrent depth is the more technical, engineering term, while opaque recurrence is the framing used when the discussion turns to safety and monitorability.

Has OpenAI confirmed that Astra uses opaque recurrence?

Not exactly. OpenAI's own Astra system card reportedly confirms the model's chain-of-thought monitorability is lower than earlier models, but the company hasn't officially named recurrent depth or any specific shared-layer architecture as the cause. The technique itself was first reported by The Information, not announced by OpenAI.

Is opaque recurrence the same as neuralese?

No. Neuralese describes a hypothetical worst case where a model reasons entirely in internal numeric representations with no readable language at all. No shipped model does this today, and OpenAI has pushed back on comparisons between Astra and that scenario.

Why do AI safety researchers care so much about chain-of-thought monitoring?

Because it's one of the few tools available for catching a model's misbehavior after the fact. Techniques that reduce how much reasoning shows up in readable text also reduce how much a monitor watching that text can actually catch.

Could OpenAI increase how much opaque recurrence Astra uses?

Researchers, including Redwood Research's Ryan Greenblatt, describe the current loop count as more of an adjustable setting than a fixed limit, meaning a future Astra update could lean on the technique more heavily without a new architecture.