GPT-6 Astra can solve much harder problems without writing out how it got there. I think that matters more than another benchmark win.
There is a number buried in the Astra safety work that I have found difficult to forget: 30.9 minutes.
The UK AI Safety Institute estimates that GPT-6 Astra can solve mathematical problems requiring about 30.9 minutes of human work without producing chain-of-thought reasoning. GPT-5.6 Sol managed 3.6 minutes on the same evaluation.
I would not take 30.9 too literally. AISI itself warns that contamination may affect the estimate, and these measurements will improve. What I care about is the gap.
I had been looking at the same problem independently. My No-CoT Reasoning Index uses 35 tasks to test how far models can reason when you take away the usual textual scratchpad. On the fitted scale, Astra had roughly 8.5 times the odds of solving benchmark problems as the next model, Claude Fable 5.1. On synthetic arithmetic tasks with strict dependencies, Astra reached an effective depth of around 7.3 steps at the 50% success threshold. The previous frontier was about 4.1.
A qualification is important here. Astra is not "8.5 times more intelligent". Nor have we peered inside the network and counted 7.3 thoughts. These are behavioural measurements. They tell us how much structured computation survives before performance falls apart.
What they suggest is still striking: Astra can get much more work done without first turning that work into words.
That may be a bigger shift than it sounds.
We don't know where the reasoning went
I used to describe no-CoT performance too casually as reasoning "in a single forward pass". I no longer think that is a safe assumption.
No visible chain of thought tells us something about the interface. It does not reveal the architecture.
Astra might simply have learned better implicit algorithms inside an otherwise familiar Transformer. It might use some form of recurrence. There could be latent iterative computation that never becomes text. We do not know.
Recurrence remains an attractive hypothesis because public research now shows that the mechanism works.
Huginn allows repeated internal computation at inference time. Ouro uses shared weights recursively and reports an interesting pattern: recurrence seems particularly useful for manipulating knowledge, rather than simply storing more facts. Microsoft's LOTUS work similarly shows that latent iterative reasoning can approach explicit chain-of-thought performance while cutting thought-phase latency in its experiments.
None of this proves Astra is recurrent.
It does make one idea much harder to dismiss: future models may buy additional reasoning by spending more computation on hidden states instead of producing longer strings of intermediate text.
Once that happens, parameter count becomes a less satisfying description of a model.
Two systems could contain similar numbers of learned weights while spending very different amounts of computation on the same question. One applies its machinery once. Another reuses some of it repeatedly, or decides dynamically that this particular problem deserves more work.
We are used to asking how big the model is. Increasingly, I think we will have to ask how much computation it decides to spend after it has seen the problem.
That is a rather different scaling law.
The economics get awkward
Tokens have been convenient because they are visible. Customers can count them. Providers can bill for them. Analysts can use them as a rough proxy for inference demand.
The connection was never exact. It may now be getting much worse.
Imagine two requests that each produce a 500-token answer. One is easy. The other causes the model to spend far more computation internally before giving an equally short response.
The invoices can look similar while the accelerator workloads are nothing alike.
If that becomes common, problem difficulty starts showing up directly in gross margin.
Routing then matters enormously. You want cheap models handling questions that do not deserve expensive reasoning, while difficult requests get more compute. Capacity planning becomes harder too. A short answer may occupy hardware for a long time before the first useful token appears.
This is why I am increasingly sceptical of forecasts that treat output-token growth as a clean proxy for AI compute demand.
A model can say less and compute more.
There is a hardware consequence as well. Reusing parameters may save some memory pressure, but repeated computation still costs FLOPs and time. Depending on the architecture, you can end up exchanging long autoregressive sequences for more work on hidden representations.
So the bottleneck moves rather than disappearing.
That makes model architecture, accelerator design and serving software increasingly inseparable. A beautiful architecture that is difficult to schedule efficiently can have terrible production economics. Conversely, a lab that knows exactly how to map variable internal reasoning onto its hardware may have an advantage that barely appears in benchmark tables.
The safety issue is more basic than deception
Chain of thought became a monitoring tool almost accidentally.
Models needed a textual scratchpad to solve harder problems. Safety researchers realised that the scratchpad sometimes contained useful evidence about what the model had noticed, intended or planned.
That arrangement depends on the reasoning being there to read.
Astra weakens that assumption.
OpenAI reports that Astra tends to produce shorter, less informative chains of thought than GPT-5.6 Sol and performs worse on several CoT monitorability measures. Yet Astra also behaves better on a number of safety evaluations.
I don't see a contradiction. Reliability and observability are separate properties.
More importantly, monitorability can deteriorate without the model trying to hide anything. If the load-bearing computation simply no longer needs to pass through language, the transcript tells us less.
OpenAI's response is revealing. Its Astra safety stack goes beyond reading chain of thought. It monitors actions and broader trajectories and also uses activation-based classifiers. The company says expanded misalignment monitoring carries significant compute cost.
In other words, observability is becoming something labs have to build and pay for.
For obvious actions, this may work well. If an agent exports credentials or deletes a database, you have evidence in the environment.
The difficult cases are quieter. Strategic underperformance can resemble incompetence. A deliberately omitted fact can resemble an ordinary mistake. Manipulation can look like bad judgement.
Those are precisely the cases where knowing something about the decision process becomes useful.
Then there is controllability
Astra is also much better at controlling the chain of thought that it does reveal.
OpenAI reports 60.9% compliance with certain CoT-control constraints for Astra, compared with 16.1% for GPT-5.6 Sol and 1.7% for GPT-5.5 Thinking. UK AISI found the same direction in a separate evaluation, with 93% versus 48%.
I would not translate this into a claim that Astra is secretly deceiving its monitors. The result says something narrower and more defensible.
The reasoning trace is becoming easier for the model to shape.
That should bother anyone who wants to use the trace as an audit log. A log is most useful when the process being monitored does not have complete freedom to rewrite it.
OpenAI also found that controllability rose during reinforcement learning and correlated with rising no-CoT capability, despite finding no substantial direct reward pressure to make the chain of thought more controllable.
We do not know why.
One explanation I find plausible is that once the model depends less on written reasoning to do the actual computation, the visible text becomes more like a report written after part of the work has already happened.
That is still a hypothesis. Future models should tell us whether the relationship is real.
What I would measure next
I no longer think another aggregate reasoning benchmark is enough.
I would like to see an observability curve.
Give models progressively harder tasks and measure how much capability they can exercise before they must produce some reliable external signal of what they are doing.
Sometimes that signal will be language. For agents it may be tool calls, file changes or other actions. Eventually activation-level telemetry may become useful too.
Then compare systems at the same capability level.
Two models could have identical benchmark scores while giving monitors very different amounts of information.
That difference may turn out to matter more than another small gain on a leaderboard.
Astra's architecture is still unknown. The recurrence hypothesis may prove right, partly right or irrelevant.
The empirical result survives.
A frontier model can now solve a much harder class of problems without writing down much of the intermediate work. Its visible reasoning has become less informative, while the model has gained more control over the reasoning that remains visible. OpenAI is already compensating by spending additional resources on monitoring elsewhere in the system.
For most of the Transformer era, more reasoning left something obvious behind: a bigger model, a longer context or a screen full of reasoning tokens.
Astra suggests we should get used to a stranger possibility.
The answer may stay short.
The expensive part may be everything that happened before we got to see it.