22% to 2.4% on Safety. Monitorability Went the Other Way, and OpenAI Called the Decline Serious

Surya Pratap
By Surya Pratap

September 8, 2026

11 min read

AI & Technology
The two directions in the Astra system card set side by side — on the left what got better, unwanted behaviour falling from 22% on GPT-5.6 Sol to 2.4% on Astra on OpenAI's own internal safety benchmark, with Astra reported ahead of Sol and Fable on bug finding, terminal execution and codebase questions, and on the right what got worse, recurrent depth looping the same query rather than writing reasoning out in steps, leaving fewer legible traces, and a monitorability decline OpenAI itself called seriousTwo numbers, opposite directionsHover to explore
Safer to run and harder to explain, from the same document. Only one of those halves got written up as the story.

Yesterday I wrote about enterprises getting tools that inventory every agent on a machine and block the ones nobody approved — a week where the question became show me what this agent did, and who let it.

Two days before that, the frontier moved in the opposite direction.

OpenAI shipped Astra on 3 September. It is, by their account, the best software engineering model they have built, and it behaves markedly better than its predecessor. It also reasons in a way that leaves fewer legible traces, and OpenAI's own system card says monitorability declined. They called the decline serious.

1. What the system card actually says

Astra, as reported and as documented

Two directions in the same release, both from OpenAI

  • Unwanted behaviour fell from 22.0% to 2.4% on OpenAI's internal safety benchmark, comparing GPT-5.6 Sol with Astra. Lower is better; that is a large, real improvement.
  • Astra is reported ahead of Sol and Anthropic's Fable on bug finding, terminal execution and codebase questions — billed as the best model for software engineering to date.
  • It uses recurrent depth, also called opaque recurrence: the model processes the same query several times in a loop rather than leaving a conventional sequential chain-of-thought record.
  • The result, in the reporting, is that it leaves fewer legible traces than the sequential reasoning it replaces.
  • OpenAI's system card confirms monitorability is lower than earlier models, and the company called the decline serious.
  • Access started with Daybreak cybersecurity program customers, then Pro, Plus, Enterprise and Business plans plus the API — a capability significant enough that rollout order was itself a safety decision.

Jakub Pachocki, OpenAI's chief scientist, put the tension plainly: "We kind of take this visibility for granted, and we are seeing that as model capabilities are increasing, monitorability is getting more challenging." He also said preserving chain-of-thought monitoring has been a core goal since their first reasoning models, which I read as sincere and unresolved rather than contradictory.

2. The trade, stated without spin

Strip the launch language away and the shape is simple.

It misbehaves less. It explains itself less. Both are true.

Those are not opposites, and the first is not a substitute for the second. A model that behaves well nine times out of ten and cannot tell you why is a different operational object from one that behaves worse but leaves a readable record. The second is debuggable. The first has to be measured from the outside.

Safety researchers reacted to the second half. Buck Shlegeris of Redwood Research said he was "extremely concerned by the reporting that Astra uses opaque recurrence", warning that scaling the technique further would destroy chain-of-thought monitorability. His colleague Ryan Greenblatt described the endpoint as a model that reasons almost entirely in latent space. Zvi Mowshowitz argued it breaks a norm the labs had worked to establish.

Why I am not treating this as a safety story

Those concerns are about frontier oversight, and I am not the person to adjudicate them. The founder-relevant fact underneath is narrower and harder to argue with: the artefact you were implicitly relying on to explain your product's behaviour just got thinner, at the same moment your buyers started asking for it in writing. That is true whether or not the alignment debate resolves well.

3. Why the timing matters more than the technique

Last week produced two demands and one supply, and they point in opposite directions.

The demand. Enterprise tooling now traces prompt to identity to tool call to system action, and blocks agents nobody approved. Your buyer's security team is being handed the vocabulary to ask what your agent did and why, as a procurement question rather than an incident question.

The supply. The best available model for the work is one whose internal reasoning is, by its maker's own measurement, less legible than the model it replaces. If your answer to "why did it do that" was ever going to be "here is the chain of thought", that answer is depreciating.

This is not a reason to avoid Astra. It is a reason to stop treating the model's self-report as a component of your product's accountability story, because you do not control its legibility and it is trending the wrong way.

4. If you ship agent products

Auditability into the harness

Move
Everything defensible about your agent's behaviour should be something you recorded, not something the model narrated: inputs read, tools called with arguments, files touched, external calls made, what changed. That log is yours, it is stable across model swaps, and it is what a reviewer actually wants.

Shipping reasoning text as evidence

Stop
Surfacing a model's explanation in your UI is fine as a product affordance. Treating it as an audit record was always shaky — it is a generated artefact, not a transcript of computation — and recurrent depth makes that gap explicit rather than creating it.

Outcomes, repeatedly

Measure
When you cannot inspect the reasoning, the remaining lever is running the same task many times and looking at the spread. That is the discipline behind running 507 agent tasks twenty times each: one pass tells you almost nothing, twenty tells you what you actually ship.

Model portability

Assume
Anything you build on the assumption that reasoning is inspectable is a bet on one architecture. Keep the boundary between your harness and the model clean enough that you can swap in whatever is best next quarter without your logging story changing.

5. What to log when the model will not tell you

The useful reframe is that an agent's accountability was never really about its thoughts. It was about its effects.

The full call graph

Record
Every tool invocation with its arguments and result, ordered, with the identity the call ran under. This is the same shape enterprise tooling now builds externally — capturing it yourself means you can answer the question before someone else has to reconstruct it.

What entered the context

Record
Which files, documents, retrievals and third-party instructions were in the window for each step. When something goes wrong, the input that caused it is usually far more informative than any explanation of it, and it is a fact rather than a generation.

The decision boundaries

Record
Where the agent chose between branches, where it retried, where a human approved. You cannot log why it chose, but you can log that a choice existed and which way it went — which is most of what an investigation needs.

None of this is new advice. What changed is that the fallback quietly disappeared: teams that skipped this were relying, without deciding to, on being able to ask the model afterwards.

6. What I would not conclude

This is not a claim that Astra is unsafe. By the one number OpenAI published on this, it behaves considerably better than the model it replaces. Monitorability and behaviour are different properties, and it is entirely coherent for one to improve while the other regresses.

"Fewer legible traces" is not "no traces". Reporting on the technique describes a reduction in legibility, not the elimination of a chain of thought. The strong version — reasoning moving fully into latent space — is what researchers warn scaling could produce, not what has been documented.

I am reading one release as a direction. One model, one architecture choice, one system card. If competitors do not follow, this is a footnote rather than a trend, and the honest position is that we will know in a year. What is not speculative is the trade in this release, because OpenAI documented it.

The honest summary

The Astra launch is genuinely good news for anyone building software with agents. Better coding, markedly better behaviour, and a company willing to publish the number that makes it look worse — the monitorability decline came from OpenAI, not from a critic.

The part worth acting on is small and structural. Your product's ability to explain itself has to come from your side of the boundary now. Not because the model is untrustworthy, but because its legibility is a property you neither control nor were promised, and it moved in the wrong direction in the same week your buyers got the tools to start asking.

Founders who already log tool calls, context contents and decision points lost nothing this week. Founders who were planning to show a reasoning trace when someone eventually asked just found out that plan has an expiry date on it.

Sources: TechCrunch, "OpenAI's new reasoning technique alarms AI safety experts" · TechCrunch, "OpenAI launches Astra, its powerful (and controversial) new model" · Implicator.ai on the Astra system card and monitorability · Gizmodo on monitoring how the model thinks · Benchmark figures, quotes and the description of recurrent depth are as reported; the argument about where your audit trail belongs, and the cautions in section 6, are mine.

IdeaToMVP Academy

Want to build with AI — not just read about it?

4-week live cohort for founders. Learn to ship AI agents, scope MVPs, and automate your business — taught by the same team that writes these guides.

Explore the Academy →
Share this post :