GPT-6 Astra Explained: What Actually Changed, With the Numbers

The headlines went to the exotic evaluations — frontier maths, ARC-AGI, where Astra reportedly matched a human efficiency baseline on 96% of levels. Impressive, and almost useless for predicting whether the thing will be helpful on a Tuesday.

The two benchmarks worth your attention are OSWorld and ScreenSpot-Pro. OSWorld measures whether an agent can complete real desktop tasks — open apps, move files, navigate interfaces. ScreenSpot-Pro measures something narrower and more fundamental: can the model correctly identify what's on a screen and where, without any tooling to help it.

The OSWorld gap is real but modest — a couple of points over Claude Opus 5. The ScreenSpot-Pro gap is the one that should make you sit up: nearly sixteen points over its own predecessor. That's not an incremental gain. That's a capability crossing a usability threshold, and the next section is about why that particular number carries so much weight.

Here's the thing about agents that the demo videos never show you: the failure mode was almost never the reasoning. Ask a model what steps are needed to update a record in a CRM and it has always been able to tell you. Ask it to actually do it, and it would click 40 pixels to the left of the button.

Grounding — knowing precisely where an element is on a screen and what it does — is the perception layer under everything else. And perception errors compound in a way reasoning errors don't. A model that misidentifies an element 25% of the time doesn't complete 75% of a ten-step task; it completes almost none of them, because each step depends on the last one landing correctly. Multiply 0.75 by itself ten times and you get 5.6%. That's why agent demos looked magical for three steps and fell apart at fifteen.

Now run the same maths at 92.7%. Ten steps gives you roughly 46%. Still not reliable enough to leave alone overnight, but it's the difference between "a party trick" and "a tool that finishes a short job." That single number is doing more work in this release than any of the reasoning benchmarks, and it's the reason the agentic use cases suddenly look plausible rather than aspirational.

Three technical choices explain most of the behaviour change. None of them are marketing.

There's a number in the latency testing that I think deserved more attention than it got.

Cut the time per task roughly in half and you change what people are willing to delegate. An agent that takes 75 minutes to do a 20-minute job is a science experiment — you sit there watching it, which defeats the purpose entirely. At 40 minutes you can hand something over and go do other work, which is the whole proposition. OpenAI also reports it does this while spending fewer output tokens than the previous generation, and one launch customer put that saving at around 20%. Capability gets the headlines; economics decides adoption.

My favourite detail from the launch material, and one that mostly got skipped.

OpenAI ran a side-by-side: build a personal career website. The previous model went off and did it autonomously in thirteen minutes. Astra stopped after twenty seconds to ask which career the person was moving into.

Read that as a benchmark result and it looks like a regression — slower, no artifact. Read it as product behaviour and it's the most interesting thing in the release. The model made a judgement that an instruction was underspecified in a way that mattered, and declined to guess. It fills routine gaps by itself and only interrupts when the answer would change the outcome.

This is what OpenAI means when it calls Astra its most aligned model, and it's worth noticing that alignment showed up here as a usability feature rather than a tax. The reason agent output has historically needed so much rework isn't that models were unintelligent — it's that they were confidently wrong about your intent and never checked. A model that asks the right question at the right moment produces less work for you, not more.

Astra lands at the top of the market: $10 per million input tokens, $50 per million output, with a faster mode at roughly double. That puts it level with Claude Fable 5 and in a completely different bracket from the open-weight challengers — I looked at the most credible of those in the Kimi K3 review, and the price gap there is more than three to one.

Is the premium justified? For agentic work, the honest answer is probably yes for now, because the cheaper models aren't doing the same job — computer use at this level of grounding isn't something you get from a model you self-host today. For text generation, the premium is much harder to defend, and I'd point most people at cheaper options. The useful framing isn't "which model is best" but "what am I paying it to do": you're buying execution here, not prose.

Worth modelling before you commit: agentic workflows consume far more tokens than chat, because the model is reading screens and iterating. A workflow that costs pennies in a chat window can cost real money as a running agent.

This part is unusual enough to flag properly. OpenAI classified Astra as its first model to reach a Critical cybersecurity capability threshold under its own framework — meaning that with the right access, it can find software vulnerabilities that weren't previously known. It launched first to a restricted set of organisations in a vetted programme before general rollout.

The practical consequence for ordinary users: Astra ships with safeguards that can pause or stop work. In ChatGPT you may be asked to approve an action mid-task; through the API, a flagged task can halt outright. Some legitimate work will get caught in that net.

I'd call that the right call and an honest one — a lab shipping a model it publicly labels critical in a risk category, with friction it knows users will feel, is not the cynical outcome. But if you're building anything on top of Astra, design for interruption from the start. Assume a run can stop halfway and that a human has to pick it up cleanly.

This is, I think, the real constraint on the next twelve months, and it isn't a capability problem. Every lab is racing on how much an agent can do unsupervised. Nobody is racing on how you confirm it did the right thing. Ask the model to report rather than act, wherever you can. Keep runs short enough to audit. Prefer workflows that produce a reviewable artifact over ones that silently change state. Those habits are worth more right now than any prompt technique.

Depends entirely on what you're asking it to do, and I'd resist the leaderboard framing.

For operating software, running long multi-step tasks, and building things that need to actually work — websites and apps through Sites, code through Codex, browser and desktop workflows — Astra is the strongest thing available today, and the grounding numbers explain why. For writing, judgement and nuance, my ranking hasn't shifted; I laid that out in my five-assistant comparison and nothing in this release changes it. For price-sensitive bulk work, the open-weight models remain a serious argument.

The genuinely new thing here isn't a leaderboard position. It's that "can it use a computer" stopped being a demo question and started being a product decision. That's the line this release crossed, and it's the one worth watching over the next few months.