GPT-6 Astra: what OpenAI's new ChatGPT model changes for software teams

OpenAI shipped GPT-6 Astra on 3 September to a limited group and opened it to ChatGPT Plus, Pro, Business, and Enterprise users the following day, with the same model in the API as gpt-6-astra and on Amazon Bedrock. It replaces GPT-5.6 Sol as the flagship. OpenAI calls it "the world's most intelligent and aligned model", which is marketing, and says it is state of the art on computer use, browsing, software engineering, cybersecurity, science, and professional work, which is a list of claims you can check. This post is about the parts that matter if you build software: what changed, what it costs, which numbers to trust, and what to do about it this month.

The headline change is computer use, not chat

Every generation so far has been sold on reasoning. Astra is being sold on doing. OpenAI's benchmark of choice is OSWorld 2.0, where a model has to complete real tasks inside real desktop applications. Astra scores 72.6 percent at roughly 40 minutes per task, against Sol's 65.7 percent at roughly 75 minutes. Read that as two separate improvements: it gets more tasks right, and it takes about half the wall-clock time to do it.

That second number is the one that changes products. An agent that takes 75 minutes is something a person babysits. An agent that takes 40 minutes and is right more often is something a person hands a task to and checks later. OpenAI says Astra is close to twice as fast at computer use overall and can run those tasks in the background while the user keeps working in ChatGPT. Browser and screen interaction, meaning clicking, typing, and navigating, is the mechanism.

If you have been holding off on an agent that operates other software rather than calling APIs, this is the release that makes the demo credible. It does not make the production system safe on its own. Everything in our agent harness post still applies, and applies harder, because the agent can now reach more.

What changed in Codex

For coding, the interesting change is not the model's raw ability, which OpenAI describes as its best for software engineering to date, but how Codex handles long work. Agents on long tasks hit the context window and compact, which means repeatedly summarising everything so far and losing detail each time. Astra in Codex instead keeps searchable notes across context windows and can go back and find a requirement or a test result from an earlier window even when it is not in the notes. It is experimental, switched on in configuration, and OpenAI says it becomes the default in the coming weeks.

Codex can also now ask a clarifying question asynchronously mid-task rather than guessing and carrying on. Both changes point the same way: long-running agentic coding sessions that hold their shape. On Terminal-Bench 4.0, which tests exactly that kind of work, OpenAI reports 57.7 percent against Sol's 37.3 percent.

We wrote about why context engineering replaced prompt engineering earlier this year. Notes across windows is the first vendor implementation of that idea inside a mainstream coding agent, and it is worth trying on a real repository before you decide it works.

The numbers, and the caveats attached to them

These are OpenAI's own figures, which is the only source there is a week after launch.

• OSWorld 2.0: 72.6 percent, up from 65.7.
• FrontierMath Tier 4: about 98 percent, up from 83.
• Terminal-Bench 4.0: 57.7 percent, up from 37.3.
• GPQA Diamond: 96.0 percent, up from 94.6.
• ARC-AGI-3: 99.9 percent, up from 7.8.
• ExploitBench: 100 percent, up from 78.5.
• Long context: 100 percent on the 8-needle retrieval test between 256K and 512K tokens, and 96.3 percent between 512K and 1M.

Three caveats. The ARC-AGI-3 score was achieved with a stateful, expensive harness around the model, so a plain API call will not reproduce it. On Humanity's Last Exam, Astra trails Anthropic's Claude Fable 5.1 at 57.2 percent against 65.0, so "best at everything" is not the right summary. And the UK AI Security Institute reported that Astra could evade monitoring under adversarial prompting, which matters if you are relying on the model to police itself. Treat vendor benchmarks the way you would treat any supplier's claim: as a reason to run your own evaluation, not a substitute for one.

What it costs

API pricing is 10 dollars per million input tokens and 50 dollars per million output tokens, with cached input at 1 dollar. A fast mode runs up to 2.5 times quicker at double the price. Batch and flex processing run at half price, 5 and 25 dollars.

Put a real workload through that. An agent that reads a 40,000-token codebase context and writes 3,000 tokens of changes costs about 55 cents per run at standard rates. Do that a thousand times a day and it is 550 dollars a day, most of it input. Caching the stable context brings that input cost down by 90 percent, which is why the first engineering task on any Astra rollout is structuring prompts so the unchanging part is cached. The second is routing: most requests in a product do not need the flagship, and small models with a router keep the bill sane while Astra handles the hard cases.

In ChatGPT, Astra comes as GPT-6 Astra Pro on the Pro, Business, and Enterprise plans with message caps, and Plus subscribers get it inside ChatGPT Work and Codex. For Enterprise workspaces it is off by default until an administrator enables it, which is the right default and worth knowing before someone asks why they cannot see it.

The part OpenAI is nervous about

OpenAI delayed this release to add safeguards, and the model is classified at the "Critical" threshold for cybersecurity under its Preparedness Framework, the first time a public model has been. The version everyone gets refuses certain prompts in that area. The full capability is limited to a group of testers, with wider access for defensive work coming through a program called Daybreak. If your product touches security tooling, expect refusals in places Sol did not refuse, and plan for them.

There is a second, quieter concern. Astra uses a technique OpenAI's researchers describe as recurrent depth, sometimes called looped transformers, which improves efficiency but makes the model's reasoning harder to observe from outside. Safety researchers have said this makes the model harder to monitor. For a team building on it, the practical consequence is that you cannot lean on the model's visible reasoning as an audit trail. Log inputs, tool calls, and outputs yourself, as we described here.

What to do this month

1. Do not switch production traffic on launch week. Run your existing evaluation set against Astra alongside Sol and whatever else you use. If you do not have an evaluation set, that is the first job, and we explained why.
2. Try the Codex notes feature on one real repository with a long task. Judge it on whether the agent still knows the requirements after an hour, not on the demo.
3. Prototype the computer-use agent you shelved, inside a harness with permissions, a budget, and a person approving anything irreversible.
4. Restructure prompts for caching before you look at the bill.
5. Route. Reserve Astra for the requests that need it.

Astra is the first model where the agent story is stronger than the chat story. That is good news for teams that build systems and mixed news for teams that build prompts. If you want a second pair of hands on an evaluation, a harness, or an integration, that is what we do.