GPT-6 Astra: OpenAI's New Model Is Built to Finish the Work
OpenAI released GPT-6 Astra on September 3, 2026. It is the company’s new flagship model for complex reasoning, coding, computer use, scientific work, and the production of finished documents, spreadsheets, and presentations.
The benchmark gains are large, but they are not the most important part of the release. Astra is designed around a broader unit of work. It can move through software, use tools, revise its approach, and keep track of a task across a long session. OpenAI is also making a stronger claim about judgment: the model should understand the boundary of a request, continue through routine uncertainty, and pause when a missing decision could materially change the result.
That combination makes Astra feel less like a better answer engine and more like a computer operator that can be trusted with a larger assignment.
What changed with GPT-6 Astra
GPT-6 Astra brings several improvements together in one model:
- State-of-the-art results reported by OpenAI across computer use, coding, science, cybersecurity, and professional work
- A 1,050,000-token context window and up to 128,000 output tokens
- Stronger visual judgment for websites, games, presentations, and other finished artifacts
- New API support for asynchronous tool calls and mid-turn steering
- More reliable behavior when instructions change during a long task
- New memory behavior in Codex for work that spans multiple context windows
- Stricter deployment safeguards after reaching OpenAI’s Critical cybersecurity capability threshold
The model accepts text and image input and produces text output. It supports web search, file search, image generation, code execution, hosted shell, computer use, MCP, and other tools through the Responses API. Fine-tuning is not available at launch.
For developers, the model ID is gpt-6-astra.
Computer use is the center of the release
OpenAI’s launch post leads with computer use because Astra is meant to complete work inside the same applications people use. The examples cover forms, CRM updates, calendar organization, research, frontend quality checks, spreadsheets, document formatting, CAD, game development, and scientific software.
The reported results support that focus:
| Evaluation | GPT-6 Astra | GPT-5.6 Sol | Claude Fable 5.1 | Claude Opus 5 |
|---|---|---|---|---|
| Agents’ Last Exam | 59.3% | 53.6% | — | 55.5% |
| OSWorld 2.0 | 72.6% | 65.7% | — | 70.2% |
| ScreenSpot-Pro | 92.7% | 76.9% | — | — |
| AutomationBench | 41.4% | 18.1% | 31.4% | 26.9% |
| BenchCAD | 95.9% | 83.3% | 84.3% | 82.1% |
OpenAI-reported results at the maximum evaluated effort. The chart is redrawn from the GPT-6 Astra launch article.
OpenAI also reports that Astra completed its OSWorld tasks in about 47% less time than GPT-5.6 Sol in latency simulations. With an updated Codex harness, it completed tasks 1.9 times faster on Mind2Web.
These are vendor-run evaluations, and production results will depend on the surrounding agent, tools, permissions, and safeguards. Still, the pattern matters. The largest gains appear in tasks that require the model to perceive an interface, decide what to do next, and carry out several actions correctly.
This is where frontier models are heading. Generating the right instructions is useful. Opening the application, making the change, checking the result, and recovering from a mistake is a much larger product capability.
Professional output becomes part of the evaluation
Astra is trained to produce artifacts that are closer to ready for use. OpenAI highlights its ability to follow an existing template, preserve a visual system, and create polished documents, spreadsheets, and presentations without filling them with unnecessary context.
That sounds cosmetic until you consider how professional work is actually delivered. A financial model can contain correct formulas and still be difficult to review. A slide deck can contain accurate facts and still fail to communicate. A website can compile and still have broken spacing, weak hierarchy, or unusable controls.
The last mile is part of the task. A model that can inspect its own rendered output and revise it can save more time than one that produces a strong first draft but leaves an hour of cleanup behind.
OpenAI reports a smaller gain on its internal design benchmark, from 47.4% with GPT-5.6 Sol to 50.0% with Astra. That result is a useful reminder that visual quality remains difficult to measure and far from solved, even when individual demos look impressive.
Coding improves most where the environment matters
OpenAI calls Astra its best software-engineering model so far. The detailed results show where the improvement is strongest:
| Evaluation | GPT-6 Astra | GPT-5.6 Sol | Claude Fable 5.1 | Claude Opus 5 | Gemini 3.8 Flash |
|---|---|---|---|---|---|
| Terminal-Bench 4.0 | 57.9% | 37.3% | 55.8% | 52.3% | 19.1% |
| DeepSWE 1.1 | 74.1% | 72.7% | 67.4% | 73.7% | 73.8% |
| FrontierCode 1.1 Extended | 64.5% | 60.6% | 63.6% | 63.6% | 56.3% |
| Internal database migrations | 63.9% | 42.7% | 57.8% | — | — |
The small DeepSWE increase suggests Astra is not equally better at every form of coding. The much larger Terminal-Bench and database-migration gains point to a different strength: operating in a real environment, coordinating several steps, and validating changes across a system.
That distinction is important for engineering teams. The hardest part of a change is often not writing a function. It is finding the correct part of an unfamiliar repository, understanding its conventions, changing several connected pieces, running the right checks, and explaining the result clearly enough for review.
Long-running work gets a better memory system
A million-token context window helps, but even a large context window eventually fills. Long coding and research sessions have traditionally used compaction: the system summarizes earlier work and continues from the summary. Each compaction risks losing a failed attempt, a subtle requirement, or the reason behind a decision.
With Astra, Codex can keep notes across context windows and search earlier messages and tool output when it needs the original detail. The feature is experimental and can be enabled in Codex configuration before it becomes the default for Astra.
| Long-context evaluation | GPT-6 Astra | GPT-5.6 Sol |
|---|---|---|
| MRCR v2, 8-needle, 256K–512K | 100.0% | 91.5% |
| MRCR v2, 8-needle, 512K–1M | 96.3% | 73.8% |
This is a meaningful architectural change. A compressed summary asks the model to predict everything it will need later. Searchable history lets it retrieve evidence after the need becomes clear.
The result should be more useful on refactors, investigations, and other work where the path matters as much as the current state. It also makes auditing more important: persistent notes and searchable context need clear retention rules when the task contains sensitive code or business data.
Async tools and mid-turn steering make agents easier to direct
GPT-6 Astra adds two API capabilities that change the interaction loop.
With asynchronous tool calling, Astra can continue reasoning, call another tool, or answer an independent part of the request while an application runs a slow tool in the background. The application still executes the tool and returns its result using the original call ID.
With mid-turn steering, a user can send a correction or new requirement while the model is working. Over a WebSocket connection, the Responses API preserves completed work and lets the model continue with the update instead of restarting the whole request.
Developers can also change reasoning effort during a conversation with a configuration_update item while preserving the prompt prefix for caching. Astra supports low, medium, high, xhigh, and max reasoning effort. It does not support none.
These features make agents feel more like active collaborators. A long task does not have to be a sealed box that accepts one instruction and returns much later. The user can redirect it, answer a consequential question, or let independent work continue while a slow operation finishes.
The cybersecurity capability changes the deployment story
Astra is the first OpenAI model to reach the Critical level for cybersecurity capability under the company’s Preparedness Framework. OpenAI says an unsafeguarded version scored 100% on ExploitBench, discovered and used two previously unknown vulnerabilities during evaluation, and could develop exploits against hardened browsers and operating systems.
That capability can help defenders review code and patch serious flaws. It also creates obvious misuse risks.
The public version will refuse some advanced security requests, including creating proof-of-concept exploits for vulnerabilities. OpenAI plans to expand access for vetted defensive work through its Daybreak program. The deployment also includes monitoring that can pause or stop a task when the system detects potentially unauthorized behavior.
OpenAI reports that Astra is better at staying inside the user’s authorized scope. In one internal evaluation, an unsafeguarded GPT-5.6 Sol went beyond the intended target 48% of the time, while Astra did so in 0% of cases. The launch post also says Astra never tried to bypass a Codex Auto-Review denial in another internal test.
Those are encouraging results, but one caveat deserves equal attention. OpenAI found Astra’s written reasoning harder to monitor than GPT-5.6 Sol’s when researchers explicitly instructed the models to evade monitoring. The company says the model still struggles to hide the reasoning required for complex tasks and is developing auditing methods that do not depend only on written reasoning.
The release therefore contains two safety stories at once: the model is better at following boundaries, and its growing capability makes failures more consequential.
Science moves from answers to active research workflows
Astra posts strong results in mathematics and scientific work, including 97.6% on FrontierMath Tier 4, 96.0% on GPQA Diamond, and 64.6% on Terminal-Bench Science 0.1. OpenAI also says the model helped improve published bounds for both short and large gaps between prime numbers.
| Evaluation | GPT-6 Astra | GPT-5.6 Sol | Claude Fable 5.1 | Claude Opus 5 |
|---|---|---|---|---|
| Terminal-Bench Science 0.1 | 64.6% | 22.4% | 52.6% | 30.0% |
| FrontierMath Tier 4 | 97.6% | 83.0% | 87.8% | 73.2% |
| GPQA Diamond | 96.0% | 94.6% | 93.7% | 93.7% |
| HealthBench Professional | 63.4% | 60.5% | 58.1% | 56.4% |
OpenAI-reported results. Cybersecurity evaluations shown here used models without production safeguards. The chart is redrawn from the GPT-6 Astra launch article.
The practical shift is the combination of reasoning and software use. A research model can inspect data in specialized tools, write and run code, generate plots, test an idea, and help a researcher decide what to investigate next.
That does not make the model an independent scientist. Proofs still need verification, experiments need reproducibility, and conclusions need domain experts. It does make the useful unit of assistance much larger than answering a technical question from memory.
Context, price, and availability
GPT-6 Astra is initially rolling out to a limited set of organizations. OpenAI says access will expand over the following days to ChatGPT Plus, Pro, Business, and Enterprise plans, the OpenAI API, and AWS. Enterprise administrators must enable it for their workspaces at launch. Pro, Business, and Enterprise users will also receive access to GPT-6 Astra Pro.
Standard API pricing per one million tokens is:
| Usage | Price |
|---|---|
| Input | $10.00 |
| Cached input | $1.00 |
| Cache writes | $12.50 |
| Output | $50.00 |
Prompts above 272,000 input tokens cost twice the input and cache rates and 1.5 times the output rate for the entire request. Batch and Flex processing are priced at half the Standard rates. Fast mode offers up to twice the speed at twice the Standard price, though OpenAI documents restrictions for EU data residency.
The 1,050,000-token window is valuable, but it should not be treated as free storage. Long prompts can become expensive quickly, especially after the higher long-context rate begins. Retrieval, caching, and deliberate context selection still matter.
How I would evaluate Astra
The best test is a complete unit of work that your current model struggles to finish:
- Give it a bug that crosses several services and requires browser or terminal verification.
- Ask it to update a polished document or spreadsheet while preserving an existing template.
- Interrupt a long run with a changed requirement and check whether it preserves the original constraints.
- Compare reasoning efforts on quality, elapsed time, token use, retries, and human corrections.
- Test legitimate security tasks to learn where safeguards pause or block the workflow.
- Review whether its notes and final report make the full run easy to audit.
Track cost per accepted result, not only cost per token. Astra is expensive, but a higher token price can still be economical if the model finishes more work, uses fewer output tokens, and needs fewer restarts.
The practical takeaway
GPT-6 Astra is OpenAI’s clearest attempt yet to turn a frontier model into a reliable operator for end-to-end work. Its strongest improvements appear where reasoning meets an environment: navigating software, coordinating tools, preserving context, producing finished artifacts, and adjusting to new instructions without losing the task.
The release also shows the cost of that progress. Cybersecurity capability has reached a threshold that requires stricter access and live monitoring, while written reasoning has become harder to inspect in some adversarial tests.
Astra should be evaluated as a system, not a chatbot. The model, harness, tools, permissions, memory, and safeguards all shape the result. For teams already building long-running agents, that system-level improvement is the reason to test it.