OpenAI's Second Looped Model: What the DevDay 'Forbidden Axis' Leak Actually Claims

There is exactly one source for the claim this article is about, and it is a single post on X. On September 24, the account @scaling01 wrote that the vendor "opened the floodgates and will release their second looped language model besides GPT-6 Astra on DevDay," describing recurrent depth as "the forbidden axis" and noting that it is "no longer forbidden." That is the whole of it: no model name, no model ID, no price, no date beyond the September 29 DevDay keynote in San Francisco, and no word from the vendor. What makes the claim worth a reader's time is not the tweet but the shipped facts underneath it. GPT-6 Astra, which the vendor released on September 3, is the first production model from any major lab that reporting has tied to a looped, recurrent-depth architecture. GPT-6 Sol and GPT-6 Luna, shipped September 22 at $2 in / $10 out and $0.10 in / $0.50 out per million tokens, turned that flagship into a price ladder. A second looped model would mean the vendor is no longer treating recurrent depth as a one-off bet but as standing architecture — a bigger claim than any single launch, and a much harder one to check.

This is a what-we-know-so-far piece. Everything attributed to a poster or to anonymous reporting is labelled as such, and nothing here should be read as a release.

Why the phrase 'forbidden axis' is the most interesting part of the tweet

The wording is the poster's own, not a term of art, but it points at something real. In transformer scaling there are three obvious axes: parameters, data and training compute. Depth-by-recurrence is a fourth, and it is a strange one. Instead of stacking N distinct blocks, a looped model reuses the same small stack of blocks R times, so effective depth is roughly the layer count multiplied by the loop count while the parameter count stays flat. Google DeepMind set out the theory in Reasoning with Latent Thoughts: On the Power of Looped Transformers, and the widely-cited Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach made the practical case.

It is not free depth. The iso-depth scaling work on looped language models puts the recurrence-equivalence exponent at roughly 0.46 — meaning one extra loop buys you about 46% of what a genuinely new block would have bought. You are buying depth at a discount, and paying for it in serial compute rather than memory. That is a favourable trade if you are memory-bound or want a small model to behave like a large one, which is exactly the trade the cheap tiers of any family are looking for.

So why "forbidden"? Because the computation that happens inside the loop happens in hidden state, not in emitted tokens. Chain-of-thought monitoring — reading what the model writes down while it thinks — has been the industry's main assurance tool since reasoning models arrived, and it is the tool that made the July Hugging Face agent incident legible to investigators at all. A model that does more of its work in latent space gives that tool less to read. That has been the argument against looping at the frontier for two years, and it is why the technique spread in open weights — ByteDance Seed's Ouro at 1.4B and 2.6B, and Nanbeige4.2-3B, which runs a 22-layer stack through twice — while the labs with published safety commitments stayed away from it. Alibaba's MeSH and SpiralFormer papers attacked the same problem from the efficiency side.

What OpenAI has actually said, and what it has not

The reporting that started this is The Information's, on September 1 and 2: that Astra uses a technique called recurrent depth, also described as opaque recurrence. That is a well-sourced outlet with a real track record, and it is still reporting rather than documentation. OpenAI has never published an architecture paper confirming a looped design, and Sebastian Raschka's widely-read breakdown of Astra says plainly that the looped structure is inferred from public statements — his reconstruction has Astra running its 22 blocks twice for 44 effective block applications, with two loops optimal and more destabilising training.

What OpenAI's own people have said is narrower and more careful than either the coverage or the backlash suggested. Chief scientist Jakub Pachocki posted on September 2 that the computation-graph depth of frontier models, Astra included, sits within a factor of two of GPT-4 — a bounded amount of looping, not the extreme recursion some headlines implied — and pushed back on what he called confused reporting, while conceding that chain-of-thought monitoring is fragile and trending in a negative direction. The Astra system card reportedly notes that monitorability of reasoning traces is a step down from GPT-5.6 Sol, which is a real admission and does not depend on which architecture caused it.

The safety reaction was loud. Redwood Research's Buck Shlegeris said he was extremely concerned and warned that scaling recurrence up could "totally destroy CoT monitorability"; Ryan Greenblatt and Zvi Mowshowitz made the same argument in different registers. The most useful counterpoint came from Raschka: OpenAI has withheld raw reasoning traces since the o1 generation regardless of architecture, and a stronger model emitting a shorter chain of thought is not by itself evidence of a hidden reasoning channel.

Put those two paragraphs together and you get the state of play the tweet is gambling on. "Astra is looped" is credible reporting that OpenAI has declined to confirm. "A second looped model ships on September 29" is one post.

Five September OpenAI leaks, and where this one sits

September produced a dense cluster of OpenAI leak stories, and the useful thing about them is that they are not all the same class of evidence.

• September 3 — the strings gpt-6-astra and gpt-6-astra-aeon appeared in a Statsig feature flag inside Codex Desktop, screenshotted by @notjazii and amplified by @kimmonismus. The Aeon agent story grew out of that. Five weeks on there is still no product page, no price, no documentation and no benchmark for Aeon, and no model ID that resolves.

• September 21 — a "GPT-6 Sol medium" string surfaced in NVIDIA merge records.

• September 22 — three Azure registry paths, for gpt-6-sol, gpt-6-luna and gpt-6-astra-minor, were posted from the Chinese developer forum locdd.com as a live Microsoft URL. When we fetched the public playground configuration endpoint the next day, the three new names were not in it; the registry carried gpt-6-astra and the older GPT-5.6 generation entries instead.

• September 22 — GPT-6 Sol and GPT-6 Luna shipped. Price, model IDs, SDK release notes, a Bedrock listing, a GitHub Copilot picker entry and a Perplexity default all followed within a day.

The pattern is not subtle. The leak classes carrying an artifact inside a surface that actually ships — an SDK release note, a cloud registry, a desktop feature flag — kept turning into products. The leak classes that were only a name did not. Today's claim, a second looped language model out of OpenAI on DevDay, carries no artifact at all: no string, no flag, no registry path, no price row, no model ID. That does not make it wrong. It makes it uncheckable from the outside, which is a different and more honest description.

The DevDay slate around it is real, and unusually well documented

The one thing you can date precisely is the event. DevDay 2026 is confirmed for Tuesday, September 29, at Fort Mason in San Francisco, with Sam Altman keynoting and a free livestream — OpenAI announced the date back in April.

What is expected in it has been telegraphed harder than usual. Altman posted on September 15 that OpenAI had a "big ship this week, and then for devday ship x 6," and walked the first half back the following evening: "the main thing i was excited about launching this week will be next week instead, but imo worth the wait!" Product lead Tibo Sottiaux, who had framed the week as DevDay-sized, said on September 19 the release was still coming on Tuesday, and on September 22 it did — Sol and Luna, plus a banked Codex usage reset for paid accounts. Read "ship x 6" as a count of six things shipping around DevDay and a second looped model fits comfortably in the ordinary sense of the phrase; read it as hyperbole and it fits not at all. Either way it is a founder's post, not a roadmap.

Adjacent leaks point the same direction without naming a model. A Codex Cloud build surfaced in desktop ChatGPT build 9922 with Tailscale and proxy integrations, and an onboarding flow showed developer plan tiers — Free, Prototype and Accelerate, the last at $50 — days before the keynote. Neither is a looped model. Both are consistent with a DevDay that is heavier on platform than on research.

If it is real, which model is it?

Nobody has reported an identity, so the following is inference and should be read as such.

The shortest path to "OpenAI's second looped model" is an Astra successor. Altman has said more capable models are coming "very soon," and the cheapest way to build one on a recurrent-depth base is to keep the architecture and raise the loop budget — more recurrence per token rather than more weights. That reading also explains the "floodgates" framing best, because a second flagship on the same architecture is a statement that the first one worked.

The second reading is a new tier inside the existing GPT-6 line. The naming grammar has already thrown up gpt-6-astra-minor, gpt-6-sol and gpt-6-luna strings, and a looped sibling at a different depth budget is entirely consistent with a family that now spans $0.10 and $50 per million output tokens. A cheaper looped model would be the version of this that a reader most feels in the wallet.

The third reading — a looped open-weights release — is the least supported. It would explain the phrase better than anything else, and the open looped literature it would sit beside already exists in Ouro and Nanbeige4.2-3B, but OpenAI has announced nothing in that direction for this generation, and inventing a product to fit a word is how leak coverage goes wrong.

What would make this checkable before September 29

Watch the surfaces that resolved the last three leaks, in this order:

• A model ID that resolves in OpenAI's API, or a new row on its pricing page.

• A release note in the openai-go or openai-node SDK naming new model identifiers — that is exactly how Sol and Luna leaked their own arrival, with SDK v3.65.0 shipping model identifiers hours before the announcement page went up.

• A Bedrock or Azure listing, or a fresh Statsig flag string in a desktop build.

• An architecture sentence in a system card. This is the one that would matter most and arrive last, because OpenAI has never confirmed the looped design for Astra.

Anything short of the first three is a name, and names have been the least reliable artifact of this whole cycle.

Why it matters even if the tweet turns out to be wrong

Two things change if recurrent depth becomes standard rather than exceptional.

The first is assurance. If the next generation does more of its reasoning in hidden state, then any evaluation that depends on reading a model's written chain of thought loses signal — and that includes third-party safety evaluation, not just OpenAI's own monitoring. That is a procurement input for anyone with an assurance requirement, and it will not be visible in a benchmark table.

The second is the shape of the price ladder. Looping trades parameters for serial compute, so it moves cost from memory to time: potentially cheaper to host, potentially slower per token. The GPT-6 line already prices that tradeoff explicitly — GPT-6 Astra at $10 in / $50 out per million tokens is the depth model, GPT-6 Sol at $2 / $10 is the fast one, GPT-6 Luna at $0.10 / $0.50 is the high-volume one. All three are live on OrcaRouter at OpenAI's list price with no markup, so if a fourth, looped model lands on September 29, the rate card on our side is the vendor's rate card the day it ships — and a vendor price cut is live here the same day it is live there.

The practical use of a leak like this is not prediction, it is preparation. A model that might ship in five days and has no independent benchmark is precisely the case automatic failover exists for: point a route at the new model, keep GPT-6 Astra or GPT-6 Sol behind it, and a bad first week costs you a fraction of your traffic instead of your production path. That is also the sensible way to test a depth-heavy model — the routing DSL composes it into one call beside the models it is meant to replace, and model fusion will run a panel of them against the same prompt, which is a faster read on a new architecture than any launch post.

What is actually true tonight

One post on X says OpenAI's second looped language model arrives on September 29. No model ID, no price, no name, no second source, no artefact. Underneath it: a flagship shipped on September 3 that reporting says is looped and that OpenAI has never confirmed is looped, an admitted decline in reasoning-trace monitorability relative to GPT-5.6 Sol, a chief scientist who says the looping is bounded to within twice GPT-4's compute-graph depth, and a cheap tier shipped on September 22 that made the architecture question commercially relevant rather than academic.

That is a thin claim resting on a thick story, which is the normal shape of a leak five days before the event. If a second looped model appears at Fort Mason on Tuesday, the interesting detail will not be the benchmark number — it will be whether the system card repeats the monitorability caveat. That single sentence is what tells you whether "no longer forbidden" is a slogan or a policy.