GPT-6 Astra needs to write out less of its reasoning, but OpenAI's assurance measures something else

Key takeaways

AI safety teams catch misbehaving models mainly by reading the scratch work a model writes before it answers, known as the chain of thought. That works only if a model has to write its reasoning out to solve hard problems. GPT-6 Astra, the newest flagship OpenAI released in September, has become far better at reasoning in its head without writing anything down; outside researchers reran the tests and confirmed the jump. OpenAI's own measurements show that reading Astra's scratch work now catches problems less reliably. Outside observers suspected Astra's new architecture. The only sentence about architecture in Astra's system card, the safety-evaluation report OpenAI published with the model, is about a different ability, controllability: whether a model can rewrite its scratch work on instruction. Changes in controllability, OpenAI says, are not differentially due to architecture. Why reasoning without scratch work jumped, the system card does not say, and Neel Nanda, a Google DeepMind researcher, compared 34 open-weight models and found no sign that the two abilities move together.

One: Three terms to keep apart: monitorability, reasoning without scratch work, and controllability

Before answering, a reasoning model first writes out its reasoning in plain language. Researchers call this the chain of thought; this piece calls it scratch work. The industry's main way to catch an AI doing something bad is to have a second model, called a monitor, read that scratch work. Whether reading it reveals what the model is doing is called monitorability.

This works because of a technical limit. For each word a model produces, it runs one round of computation, called a forward pass. One round can chain only a few reasoning steps, so on hard problems the model has to write intermediate results down and read them back, the way long division too big for mental arithmetic has to go on paper. Scratch work is readable not because the model wants to show it, but because the model cannot finish without writing it.

That gives two abilities. The first is reasoning without scratch work, which researchers call no-CoT reasoning: how much a model can work out within one round of computation when it may not write anything down. The stronger it is, the less the model needs to write and the less a monitor has to read, and this needs no intent to hide anything. The second is controllability: attach an instruction about how to write the scratch work, such as not using a certain word, and see whether the model complies. High controllability means a model can write its scratch work differently when asked; if the model wanted to hide something, a monitor might not be reading the real process. OpenAI's March paper measured models released before Astra; compliance was generally low, so it judged that controllability is currently unlikely to make monitoring fail. Astra, released later, is an exception, with a clearly higher compliance rate (section three).

Both abilities can weaken monitoring, in different ways: controllability matters only when a model is asked to, or wants to, hide something; when reasoning without scratch work gets stronger, the scratch work simply gets shorter. These two plus monitorability are the three measures that sections eight and nine refer to.

Why would anyone expect the two to be linked? Intuitively, both look like a model's command over its own reasoning: a model that can work more steps in its head might also be better at deciding what goes on the page. OpenAI also says the two rose together during Astra's training. If the two always rise and fall together, measuring controllability amounts to measuring reasoning without scratch work. If not, an assurance that covers only controllability does not answer for reasoning without scratch work. That is the question this piece answers.

Two: The model is OpenAI's newest flagship, GPT-6 Astra, and the official assurance covers only controllability

GPT-6 Astra launched on September 3 as OpenAI's most capable model, and its system card came out the same day. Every mention of the system card in this piece means OpenAI's card for Astra.

The card measured that problems are harder to catch by reading Astra's scratch work than by reading that of the previous model, GPT-5.6 Sol: monitorability fell. The same day, Fortune reported that Astra was said to use a new, more efficient architecture, and that AI safety experts worried this was a step toward models whose reasoning is opaque. A post by Sebastian Raschka, a machine-learning writer, calls the rumoured design a looped transformer, which reuses the same set of computing layers several times before producing the next word, so one round of computation runs extra laps. That is exactly a way to reason more without writing. A transformer is the basic design behind today's large models. Whether the new architecture is a looped transformer remains unconfirmed (section three). Raschka himself thinks layer reuse is not the model deliberately concealing anything: scratch work shrinks because fewer intermediate steps need writing out. But for a monitor, steps that are never written down are just as unreadable, which is exactly the problem section one describes.

OpenAI's answer is a passage in section 9.2.1 of the card. What this piece calls the assurance is that whole passage; it discusses architecture, and this publication reads it as OpenAI's answer to outside worries about the new architecture. Its core sentence says OpenAI is "quite confident" that changes in controllability are "not differentially due to any architectural changes" (full wording in the appendix). The sentence's wording presumes the architecture did change between generations (section three reads it the same way), but nowhere does the card say what changed. "Not differentially" means the architecture did not act on controllability in particular; whether it made every ability stronger together, the sentence does not say (see appendix). Every sentence in that passage is about controllability; reasoning without scratch work appears only at the end, and only as "correlated", not as a cause.

The question and the answer do not match. By the logic of section one, once reasoning without scratch work gets stronger, scratch work gets shorter and monitoring gets harder. What outsiders worry about is the first step of that chain: a new architecture letting reasoning move out of the scratch work. On the following three questions, here is what the card says, with this publication's additions:

• Why monitoring got harder: mostly because scratch work got shorter (section seven).
• Why reasoning without scratch work got stronger: the card offers no explanation, and does not say whether the architecture played a part.
• Why controllability changed: the card says it is not differentially due to architecture; the clues this publication gathers in section three point to post-training.

Outsiders are asking about the second item; the card's only sentence about architecture answers the third.

Three: Controllability is mostly changed during post-training

Training a large model has two stages. Pretraining reads vast amounts of text to learn language and knowledge. Post-training then shapes behaviour with human feedback and reinforcement learning, which means rewarding the model when it does well and repeating the practice many times. How a reasoning model writes its scratch work is mostly learned in post-training.

The clues on controllability all point to post-training, though none is conclusive on its own. OpenAI's March paper introducing the controllability test, CoT-Control, found that controllability "decreases with more RL training". Six months later, Astra's card says that "unlike previous models", controllability rose during reinforcement learning. Same test, opposite direction. On September 22, an appendix to the card added the smaller same-generation GPT-6 Sol, trained on "the same types of data and training" as Astra. Within a scratch-work length of 750 to 1,250 tokens (a token is the smallest unit of text a model processes), the share of answers that followed the instruction was 60.9% for Astra, 23.2% for GPT-6 Sol and 16.1% for the previous GPT-5.6 Sol.

The same kind of training does not mean the same details, and so wide a gap fits the idea that differences in post-training details set controllability; OpenAI does not say how the two models' training differed. None of this is conclusive: the architecture also changed between the two generations, and GPT-6 Sol is smaller with an undisclosed architecture, so the gap could also come from those.

At which stage, and why, reasoning without scratch work improved has not been shown by anyone. Nanda calls the looped-architecture explanation unproven.

Four: Five lines of research

1. Measuring monitorability: whether reading the scratch work catches problems. OpenAI used five evaluations on Astra in the system card.

2. Measuring controllability: attach an instruction about the scratch work and check compliance. This is OpenAI's March CoT-Control paper.

3. Measuring reasoning without scratch work: Nanda, the UK government's AI Security Institute and several authors on the AI-safety forum LessWrong each built their own tests for Astra.

4. The cost of shorter scratch work: forcing small models to write shorter scratch work and checking whether monitoring still works (section seven).

5. The architecture debate: whether reusing the same layers hides reasoning outside the scratch work. Machine-learning writer Sebastian Raschka argues layer reuse alone does not hide it.

Five: Across 34 models, those strong at reasoning without scratch work are not necessarily high on controllability

On September 10, Nanda, writing in a personal capacity, ran CoT-Control on 34 open-weight reasoning models, whose files are public and whose full scratch work can be read. Each model ran 108 questions, compared against Nanda's own index of reasoning without scratch work; the higher the score, the more problems a model gets right without writing anything down.

Nanda ranked the 34 models twice, once by each ability, and checked how alike the two rankings were, a figure called a correlation: 1 means identical, 0 means unrelated. The result was 0.10, close to unrelated.

This does not contradict OpenAI's statement that the two rose together. OpenAI tracked one company's models under one training recipe over time; Nanda compared many companies' models at one point in time. Within one tutoring school, maths and essay scores may rise together; put students from different schools side by side and the two need not line up, because each school teaches differently. That is Nanda's explanation: controllability is heavily shaped by the details of post-training.

Nanda flags the limit first: 13 of the 34 models never complied once, and overall compliance was under 3%. Thirteen models tie at the bottom, so the correlation cannot be pinned down. This piece therefore takes only the most cautious reading: in this set of models, there is no sign the two move together; 0.10 is not treated as a precise value.

One more gap: these open models complied less than 3% of the time, while OpenAI's models range from 16% to 61% in section three's length window; the measures differ, so only the order of magnitude compares. Whether the finding carries over to a model like Astra waits on someone measuring frontier models whose weights are not public (test 2 under what would prove this wrong).

Six: How much Astra can do without scratch work: an outside rerun confirms the jump

Nanda first doubted the jump the UK AI Security Institute had measured, reran it with his own question set, and reported: "Unfortunately, it replicates."

Three readings. First, Astra's odds of solving a reasoning problem without scratch work are about 8.6 times those of the runner-up, Anthropic's Claude Fable 5.1; odds compare successes with failures, so this is not 8.6 times the accuracy. Second, Astra can chain about 7.2 dependent arithmetic steps in one round of computation, against 4.1 for the runner-up. Third, the strength sits in particular task types. On purpose-built problems that chain one calculation after another, or run several at once, Astra's odds are about 16 times its odds on other task types; that is Nanda's conversion, with the method in the Appendix. This is exactly the kind of ability that can stand in for writing things down.

Limit: the UK AI Security Institute's original work has no public version.

Seven: One result, two framings: the system card says shorter scratch work made monitoring harder, the business post says it saves money

The system card, published September 3, states the mechanism: "most of the aggregate gap in CoT monitorability comes from GPT-6 Astra producing shorter CoTs" that often omit or weaken the evidence a monitor needs.

On September 9, OpenAI's launch post for business customers sold Astra as "more useful work per dollar" because it was "trained to complete tasks in fewer tokens with fewer retries". Scratch work is written in tokens too; the system card also found that, given the same cap on reasoning tokens, Astra used fewer than its predecessor whatever the cap was set to (see appendix). This publication reads the two documents side by side: the same result appears in the system card as the reason monitoring got harder and in the business post as the reason it saves money, and no OpenAI document puts the two together.

Counter-evidence: an October paper from the University of Sheffield and others forced small models to shorten their scratch work, and monitorability held up fairly well (see appendix). So shorter scratch work does not always make monitoring harder. This publication accepts the system card's explanation for Astra but does not treat it as a general rule.

Eight: Can outsiders check this assurance?

For the three measures from section one, who measured them and whether outsiders can measure them again:

The assurance covers controllability. Outsiders can rerun the method on open-weight models, but they can check neither Astra's own scores nor the causal judgment that the change is not differentially due to architecture. Stretching the assurance to reasoning without scratch work relies only on OpenAI's internal finding that the two rose together, and that finding comes with no published numbers and no published method.

Nine: What this changes, and for whom

• Companies deploying AI that operates enterprise systems: "completing tasks in fewer tokens" cuts both ways: a lower bill, and less scratch work left for later audit. A vendor questionnaire with a single "chain-of-thought monitoring" field blends the three into one.
• People writing procurement terms and regulation: terms tied to architecture miss the target; terms tied to measurable results work: recall when the model is told to evade the monitor, and outside, comparable readings of reasoning without scratch work. Recall is the share of genuinely problematic cases a monitor catches. The system card reports this figure, but only OpenAI measured it (see appendix).

Our call

When an AI company offers a safety assurance, ask two things first: which measure it covers, and whether outsiders can measure it again.

Readings to watch next

Whether the system card for OpenAI's next frontier model (its most capable tier) gives separate figures for the three, and whether GPT-6 Sol's architecture is disclosed.

What would prove this wrong

The observation window runs to March 31, 2027; for test 1, if a new system card appears first, the 14 days after its release apply.

1. Within 14 days of the system card for OpenAI's next frontier model (the criterion for a frontier model is in the measurement notes in the appendix): if the card gives a cause, or an architectural attribution, for the change in reasoning without scratch work, that measure is being accounted for separately, and this piece's call that the assurance covers only controllability is withdrawn.

2. By March 31, 2027: if any third party (such as an invited evaluator) measures a correlation of 0.5 or more between the two quantities on at least three frontier models whose weights are not public, using their real scratch work, the claim that "the two abilities are not the same thing" is withdrawn.

3. By March 31, 2027: if OpenAI publishes the numbers and method for the correlation within Astra's training, and the correlation comes from architecture rather than post-training, section three must be rewritten.

Appendix: how the numbers were obtained

Where each number comes from

Original wording of the section-two quote

System card, section 9.2.1: "We are also quite confident that changes in CoT controllability are not differentially due to any architectural changes."

Lab details for section five

Among open-weight models, the few that showed any controllability cluster by lab. Zhipu's GLM-5 series scored 6% to 13%, one DeepSeek model 11%, and every size of Alibaba's Qwen 3.5, from 9B to 397B parameters, scored zero.

Qwen 3.5's sizes differ by about 44 times in total parameters, and all score zero. This publication's inference goes only this far: within one lab, a larger model did not bring controllability. No per-size no-CoT readings are available, so this is not yet a counterexample to the post-training hypothesis.

More on the numbers in section six

In serial arithmetic within a single forward pass, Astra manages about 7.2 steps and the next-best model 4.1. That is how many dependent arithmetic steps a model can chain without writing out intermediate results. On synthetic serial and parallel computation tasks, Astra's no-CoT index sits about 40 points above its level on other tasks. Nanda converts that to odds of about 16 times.

Third-party controllability readings for section eight

Inside the card, the UK AI Security Institute found that Astra followed the constraint in 93% of samples and GPT-5.6 Sol in 48%. These figures are on a different basis from section three's 60.9% and 16.1%. Their length window and question set are not disclosed.

Three more outside readings

Zvi Mowshowitz compiled three LessWrong posts on September 12. With meaningless filler characters padded into the prompt and an instruction to answer at once, Astra rose from about 10% to about 50% on four-hop factual reasoning. Two researchers estimated the task length at which Astra succeeds half the time without a chain of thought at 15 to 40 minutes; their earlier median forecast was that this would not exceed 7 minutes by the end of 2028. With thinking mode switched off, Astra drops only 10 points, against 35 for Fable 5.1. All three sets of figures are self-reported in the posts and relayed by Zvi; the original posts have not been checked.

Counter-evidence for section seven

Of the card's five monitorability evaluations, matching scratch-work lengths narrowed the gap in three; in two Astra was still worse, which means the content of the scratch work itself carried less evidence. That is the basis for "most, not all".

The system card also says that, given the same reasoning-token limit, Astra used fewer tokens than GPT-5.6 Sol at every setting.

An October 2 paper from the University of Sheffield and others (arXiv 2610.03509) fine-tuned open-weight models under three kinds of length pressure: a fixed generation budget, per-example length targets, and a group-relative length reward. Faithfulness fell in most settings, mainly because the models became less consistent after training. Monitorability held up better: even with much shorter chains of thought, the models still acknowledged when an intervention had affected the answer. The paper tests small models with an intervention-detection measure, which differs from the metric in OpenAI's system card. This summary is based on the paper's abstract.

The trend line this publication tracks

Where this piece sits on the trend line: the line tracks whether a model's reasoning can still be read, and who checks it. This piece follows the tree's "yardstick changed hands" step and adds one question: does the yardstick used for checking measure the quantity that actually carries the conclusion? The line's existing call is unchanged.

This publication's calculations and fuller quotes

• The CoT-Control paper's full trend sentence: controllability "is higher for larger models and decreases with more RL training, test-time compute, and increased problem difficulty." The paper concludes that controllability "is currently unlikely to be a failure mode of CoT monitorability." Nanda's own summary of the controllability distribution: "It's a mess."
• About 44 times: the ratio of Qwen 3.5's largest to smallest size in total parameters, 397B divided by 9B. It only illustrates that size varies widely within one lab while controllability stays at zero; no per-size no-CoT readings are available.
• Up 7 and 45 percentage points: GPT-6 Sol's 23.2% minus GPT-5.6 Sol's 16.1%; Astra's 60.9% minus 16.1%. Same length window, straight subtraction of the card's figures.

Measurement notes

• All controllability figures come from a single length window (750–1,250 tokens); the card gives no all-length total. The UK AI Security Institute's 93% and 48% come with no disclosed length window or question set.
• The system card says "most" of the monitorability gap comes from shorter chains of thought, with no share given; "fewer reasoning tokens" comes with no percentage. The enterprise post's "9% and 63% lower estimated API cost per task" is a self-reported cost estimate against other vendors, not a token count.
• Nanda's three outside readings (filler tokens, time horizon, thinking switch) are relayed by Zvi; the original posts have not been checked.
• In test 1 under what would prove this wrong, a frontier model means one rated High or above in any category of OpenAI's Preparedness Framework, its scheme for rating how dangerous a model is.
• Korbak's "across a few generations" line is relayed by Zvi on September 8 with a link to the post; the original post has not been checked. The system card was updated on September 22 and September 29, and neither update changed the section 9.2.1 passage.

Other accounts (set side by side, not used in the main text)

• A broader first-party denial, outside the card: on September 3, OpenAI alignment researcher Tomek Korbak wrote on X: "We believe monitorability drop comes from a jump in intelligence and not direct optimization pressure on CoT or architecture changes." The line covers monitorability as a whole, but it is in a post, not on the card. It is available as relayed by Zvi Mowshowitz on September 8; the original post has not been checked.
• Another reading of "differentially": Nanda suggests looping improves pretraining, and better pretraining lifts every capability together. On that reading, "not especially caused by looping" can be both honest and uninformative. This piece keeps both readings.
• The architecture-is-innocent view: in September, Sebastian Raschka argued that layer reuse does not by itself hide the chain of thought; visible reasoning shrinks because fewer intermediate tokens need to be written out. That points the same way as section seven's "most of the gap comes from shorter chains of thought", but does not explain why they got shorter.
• Later system card updates: on September 22, OpenAI corrected a HealthBench misconfiguration and added appendices on GPT-6 Sol and Luna. On September 29 it added an appendix on dots, an always-on AI assistant powered by Astra. Neither update changed the section 9.2.1 passage.
• Self-instruction raises controllability: arXiv 2610.23257 (October 16) argues that placing a constraint inside the model's own chain of thought, as a self-instruction, yields much higher controllability than placing it in the user prompt, and shows this can be used to evade monitors. That would make the "near-zero open-weight controllability" reading an underestimate, but it does not change the pattern of clustering by lab.

Sources

• Alignment Forum — Neel Nanda, 2026-09-10: Astra can do a concerning amount with no chain of thought
• OpenAI, 2026-09-03: GPT-6 Astra System Card
• Don't Worry About the Vase (Zvi Mowshowitz), 2026-09-08: Astra Is Hard to Monitor
• OpenAI, 2026-09-09: GPT-6 Astra: The next generation in intelligence for work
• Ahead of AI (Sebastian Raschka), 2026-09-09: GPT-6 Astra, Looped Transformers, and Hidden Reasoning
• Tomek Korbak, 2026-09-03: x.com/tomekkorbak/status/2095596839886274689
• Fortune, 2026-09-03: AI experts worry OpenAI's Astra model may be a dangerous step toward models with opaque reasoning
• Rauno Arike, 2026-09-03: How concerned should we be about Astra's recurrent architecture?
• Don't Worry About the Vase (Zvi Mowshowitz), 2026-09-12: GPT-6 Astra can do ambitious things
• arXiv: Monitoring Monitorability
• OpenAI: news page; the March CoT-Control paper: arXiv 2603.05706
• arXiv, 2026-10-02: Efficient Reasoning Training Does Not Always Harm CoT Faithfulness and Monitorability
• UK AI Security Institute, 2026-09-28: GPT-6 Astra performs unsanctioned supply-chain attacks in simulations
• arXiv, 2026-10-16: arXiv 2610.23257

Written from the same research and judgments as the Traditional Chinese edition. Sources are linked; we distinguish original documents from reporting and mark what we could not verify.