OpenAI released GPT-6 Astra on September 3, 2026, and some multi-step workflows that were too fragile or slow for earlier agents now deserve another look. The practical shift is its ability to keep working across browsers, codebases, and business software with less supervision.

The 99.9% ARC-AGI-3 score will get the headlines. Builders should pay closer attention to Astra completing computer-use tasks in 47% less time than GPT-5.6 Sol, preserving context across long Codex sessions, and staying inside authorization boundaries more reliably. Those changes determine whether an agent can finish real work without becoming an expensive screen-sharing demo.

Astra still costs 2.5 times as much per token as Sol, its biggest benchmark claims come from OpenAI, and its safety systems can interrupt legitimate tasks. The useful question is where higher completion rates and fewer restarts change the economics enough to matter.

1.05M

Context window

72.6%

OSWorld 2.0 score

47%

Less time per OSWorld task

$10 / $50

Input / output per 1M tokens

What OpenAI actually shipped with GPT-6 Astra

GPT-6 Astra is OpenAI's new flagship model for computer use, coding, research, scientific work, and document creation. It accepts text and image input, supports a 1,050,000-token context window, and can generate up to 128,000 output tokens. Its knowledge cutoff is April 30, 2026.

The model is initially available to a limited group of organizations. OpenAI says access will expand over the following days to ChatGPT Plus, Pro, Business, and Enterprise users, as well as the OpenAI API, Microsoft Azure, and Amazon Bedrock. Enterprise access is off by default until an administrator enables it.

Developers call the model as gpt-6-astra. It supports computer use, web and file search, code execution, Structured Outputs, MCP, and function calling through the Responses API. Reasoning effort ranges from low to max; Astra does not support none.

The less obvious additions may matter more than the raw context window. Astra supports asynchronous tool calls, so it can continue independent work while your application waits for a slow tool. It also accepts mid-turn steering and can change reasoning effort during a conversation while preserving the cached prompt. These are useful mechanics for agents that run for minutes or hours, not just chat sessions that finish in one response.

OpenAI documents the full specifications on the GPT-6 Astra model page and the new agent behavior in its model guidance.

Computer use is where Astra creates distance

Earlier frontier models could click through a browser or operate a desktop, but long tasks exposed familiar problems. They lost the original goal, forgot why an earlier fix failed, treated a steering message as a new task, or guessed when they should have asked.

Astra targets that entire failure pattern.

01

User goal

Requirements and boundaries

→

02

Plan

Choose actions and tools

→

03

Act across software

BrowserCodeDocsCRM

→

04

Verify

Inspect the result and retry

→

05

Deliver

A checked, usable artifact

Mid-turn steering can change the goal while async tool calls keep independent work moving.

On OpenAI's OSWorld 2.0 simulation, Astra scored 72.6% at roughly 40 minutes per task. GPT-5.6 Sol scored 65.7% at roughly 75 minutes. OpenAI also reports a 1.9 times speedup on Mind2Web when Astra is paired with the updated Codex harness.

The demonstrations cover PCB layout in KiCad, Blender-to-Unreal workflows, form filling, frontend QA, data analysis, and business documents. The breadth is interesting because the same model must read visual state, choose actions, use domain software, and check the result. Writing an answer is only one step inside that loop.

The Codex update addresses another practical limit. Astra can keep notes when its context fills and search earlier context windows for requirements, test output, or failed approaches. That feature is experimental, but it is more useful for a week-long refactor than another oversized prompt that eventually needs to be compacted.

The GPT-6 Astra benchmarks need two readings

OpenAI reports several large gains over GPT-5.6 Sol:

These are meaningful results, especially the jump on terminal tasks and automation. They are still vendor-reported launch numbers. OpenAI says its evaluation table uses the maximum score at any reasoning effort, and research or API configurations can differ from production ChatGPT. ARC-AGI-3 also used an OpenAI Responses API harness with two settings changed to better reflect real-world performance.

The broader table is less tidy than the launch headline. Astra scored 57.2% on Humanity's Last Exam with tools, below the 65.0% OpenAI reports for Claude Fable 5.1. Its Artificial Analysis Coding Agent Index score of 67.0 also sits below the 68.1 listed for Claude Opus 5. On DeepSWE v1.1, Astra's 74.1% is only slightly ahead of Gemini 3.8 Flash at 73.8% and Claude Opus 5 at 73.7%.

That does not cancel the stronger results. It tells us where to look. Astra appears most differentiated when reasoning is connected to tools and an environment, while some general and coding evaluations remain competitive rather than dominant. OpenAI's full methodology and comparisons are in the launch announcement. Independent evaluations should decide how much of that advantage survives other harnesses.

The $50 output price changes the buying decision

Standard API pricing is $10 per million input tokens, $1 per million cached input tokens, and $50 per million output tokens. Cache writes cost $12.50 per million tokens. Batch and Flex processing cost half the Standard rate, while Fast mode costs twice the applicable rate.

For comparison, GPT-5.6 Sol is listed at $4 per million input tokens and $20 per million output tokens. Astra therefore needs to complete a task with fewer tokens, fewer retries, or materially better results to justify the 2.5 times token premium.

OpenAI argues that it can. The company reports lower estimated cost per successful task on several evaluations because Astra finishes with fewer output tokens. That is plausible for agentic work, where a cheaper model can burn money by looping, repeating failed actions, or requiring a human restart.

The long context window also has a pricing trap. Requests above 272,000 input tokens are billed at twice the input and cache rates, plus 1.5 times the output rate, for the entire request. A 1.05-million-token window is technically useful, but filling it casually is a very expensive way to avoid retrieval and context management.

Measure cost per successful task. Per-token pricing alone misses retries, tool calls, human review, and the value of finishing sooner.

Better alignment comes with a serious cyber caveat

OpenAI calls Astra its most aligned model and reports that it exceeded an authorized target in 0% of a specific impossible-task evaluation, compared with 48% for Sol without production safeguards. In another internal evaluation, Astra never tried to bypass a Codex Auto-Review denial.

Those are narrow evaluations, not proof that an autonomous agent cannot overstep in production. They do point toward a useful improvement: the model is more likely to pause on consequential ambiguity while continuing work that does not depend on the answer.

Astra is also OpenAI's first model to reach the Critical cybersecurity capability threshold under its Preparedness Framework. Without production safeguards, it scored 100% on ExploitBench, found two previously unknown vulnerabilities during evaluation, and demonstrated the ability to develop exploits against hardened systems.

The public model has tighter controls. It can assist with secure code review and patching, but it refuses advanced tasks such as creating proof-of-concept exploits. OpenAI also warns that monitoring may pause or stop legitimate defensive work. ChatGPT and Codex can ask the user to review an action; an API task will stop.

There is a second caveat worth keeping in view. OpenAI's Astra safety overview says the model produced fewer harmful outcomes overall but was harder to monitor through its written reasoning in adversarial tests. Better boundary following and weaker chain-of-thought monitorability can both be true. High-risk deployments still need least-privilege tools, confirmation gates, logs, and independent outcome checks.

A practical framework for choosing the implementation

The right implementation depends on how specific the workflow is. A custom system makes sense when the process depends on your data, permissions, and operating rules. Existing software makes sense when the category is mature and your process is fairly standard. Simpler automation remains the better choice when a rule, form, or database query can deliver the result reliably.

For teams in India, API costs are billed in dollars and OpenAI has not announced India-specific pricing, hosting, or a separate rollout schedule. Selective routing therefore matters. Classification, extraction, and routine responses can stay on cheaper models, while complex cases move to Astra only when its higher completion rate can recover the premium.

Where Astra may create real product value

The strongest opportunities share a pattern: work begins with messy context, crosses several tools, and ends in an artifact or system change that a person can verify.

Workflow pattern

Vertical operations agent

Handle a domain-specific process across email, documents, a CRM, and internal approvals.

Best signal: teams already pay people to bridge the systems manually.

Workflow pattern

Research-to-deliverable system

Turn approved sources into a checked report, financial model, proposal, or presentation.

Best signal: customers value the finished artifact more than a chat answer.

Workflow pattern

QA and migration agent

Modify software or data, run checks in the real environment, and document exceptions for review.

Best signal: every failed handoff causes delay, rework, or customer churn.

Each pattern can support a useful product, but the model is only one layer. The durable value lives in integration, permissions, domain context, evaluation, and the feedback loop that improves outcomes over time.

Test the workflow before committing to the architecture

Start with a focused pilot using 50 to 100 tasks sampled from real usage. Keep the current process or model as the control and compare Astra on completion rate, human corrections, end-to-end time, tool-call count, and total cost per accepted result.

As a practical heuristic, a workflow showing four or five strong signals is ready for a controlled pilot. Two or fewer usually means the process needs a clearer outcome or tighter boundaries before model choice becomes important.

Include messy cases. Change a requirement mid-run. Make one tool slow. Put conflicting instructions in a document. Deny a requested action and see whether the agent finds a safe alternative. A clean benchmark will not reveal how the model behaves when production pushes back.

Use the Responses API for tool-calling workflows, begin with low reasoning effort, and increase it only where the evaluation shows a gain. Audit every skill and instruction file the agent can read because Astra is more sensitive to instructions embedded in context. Put computer actions behind narrow permissions and require confirmation for payments, deletion, access changes, and external communication.

The evaluation should answer one practical question: does this workflow save or create more value than it costs to run, review, and maintain? If the answer is still unclear after 100 representative tasks, a larger build will only make the uncertainty more expensive.

That is the useful promise of Astra. It widens the set of workflows that may be reliable enough to measure. Pick one, test it against the current process, and let the evidence decide what deserves to be built.