GPT-6 Astra Arrives: What OpenAI’s New Flagship Changes for Developers and ChatGPT Users

OpenAI has introduced GPT-6 Astra, its new flagship model for complex reasoning, coding, computer use, research and document creation. The headline numbers are substantial: a 1.05-million-token context window, up to 128,000 output tokens and support for a broad collection of tools through the Responses API.

Yet the most important part of Astra is not a single benchmark or a larger context window. It is the way OpenAI is repositioning its most capable model: not merely as a system that answers difficult prompts, but as one expected to coordinate long-running work, operate tools, respond to corrections while running and carry a task through multiple stages.

That shift has consequences. Astra is expensive, and availability can still vary by account or workspace even though OpenAI’s current documentation now presents the model as directly usable. Some familiar API settings are no longer supported. Tool calling requires the Responses API. Long-context requests receive higher pricing across the entire request. And OpenAI has expanded its misalignment-monitoring documentation with concrete instructions for handling agent workflows that are flagged or stopped.

Here is what has been announced, what it means in practice and what teams should do before migrating production workloads.

Update: OpenAI’s rollout documentation has changed

Observed on September 4, 2026: OpenAI’s current developer guidance now tells builders to use gpt-6-astra in the Responses API, while the model catalog offers Playground access. Its ChatGPT and Codex model page also lists Astra across supported product surfaces. This replaces the earlier launch wording that access would arrive “in the coming days.” The change indicates a broader rollout, but account-level access should still be verified.

The short answer

GPT-6 Astra is OpenAI’s most capable general-purpose model for difficult end-to-end work. It accepts text and images, produces text, supports five reasoning-effort levels and can use tools including web search, file search, image generation, code interpreter, hosted shell, computer use, MCP and tool search.

Its API identifier is gpt-6-astra. Standard short-context pricing is $10 per million input tokens, $1 per million cached input tokens, $12.50 per million cache-write tokens and $50 per million output tokens. Requests containing more than 272,000 input tokens are charged long-context rates for the full request: $20 input, $2 cached input, $25 cache writes and $75 output per million tokens.

OpenAI initially described Astra as a staged rollout beginning with enterprises in its Trusted Access Program. The current model guide now tells developers to call gpt-6-astra through the Responses API, the model card offers Playground access, and OpenAI’s ChatGPT and Codex documentation lists Astra across ChatGPT web and desktop, Codex CLI, the IDE extension, Codex cloud, ChatGPT Credits and API access. The earlier “coming in the coming days” banner has been removed. That is a meaningful availability signal, but not a guarantee that every account or workspace has been enabled; users should confirm access in their own model picker or API project.

A model designed for completed work, not isolated answers

OpenAI describes Astra as a model built for “the hardest end-to-end work.” The phrase signals a change in what the flagship tier is expected to do.

Traditional model evaluations often focus on whether a system can produce the correct answer to a bounded question. Real professional work is messier. A useful agent may need to inspect files, search for evidence, write and test code, interact with an application, generate an artifact, notice a mistake, revise its approach and preserve context across many tool calls.

Astra’s feature set is built around that longer arc. Its 1.05M-token context window can hold large repositories, extensive documentation or multi-document research material. Its 128K maximum output offers room for substantial code, reports and structured deliverables. Computer use and hosted execution tools let it act on a task rather than only describe what someone else should do.

The practical question for teams is therefore not simply, “Is Astra smarter?” It is, “Can Astra complete enough of this workflow reliably to justify its cost and operational complexity?”

That answer will depend on the job. Astra is unlikely to be the economical default for short classifications, simple transformations or high-volume customer-service responses. It is more naturally suited to tasks where a failed handoff, incomplete analysis or repeated human intervention is already expensive.

Context and output limits

The official model page lists:

• Context window: 1,050,000 tokens
• Maximum output: 128,000 tokens
• Knowledge cutoff: April 30, 2026
• Reasoning effort: low, medium, high, xhigh and max

The large context window is useful, but it should not be confused with unlimited memory or guaranteed attention. Providing more material can increase cost and may introduce irrelevant evidence or conflicting instructions. Retrieval, careful file selection and explicit source prioritization remain important.

The pricing boundary is equally important. Once the input exceeds 272,000 tokens, OpenAI applies long-context pricing to the entire request—not only to the tokens above the threshold. Developers should therefore monitor input size before dispatch and avoid crossing the boundary accidentally because of duplicated conversation history, verbose tool output or files that could have been retrieved selectively.

GPT-6 Astra API pricing

OpenAI lists four processing options: Standard, Batch, Flex and Fast.

Standard processing

For requests with up to 272,000 input tokens, prices per one million tokens are:

• Token category: Input — Short-context price: $10.00
• Token category: Cached input — Short-context price: $1.00
• Token category: Cache writes — Short-context price: $12.50
• Token category: Output — Short-context price: $50.00

For requests above 272,000 input tokens, the full request uses these rates:

• Token category: Input — Long-context price: $20.00
• Token category: Cached input — Long-context price: $2.00
• Token category: Cache writes — Long-context price: $25.00
• Token category: Output — Long-context price: $75.00

Batch and Flex processing are priced at 50% of Standard rates. Fast mode is priced at twice the applicable Standard rates. OpenAI also states that Fast mode is unavailable for Astra when using EU data residency, so those requests must use Standard processing. Eligible regional-processing endpoints may carry an additional 10% uplift.

The cost profile makes routing essential. A mature Astra deployment should decide which steps genuinely require the flagship model and which can be delegated to a less expensive model. For many systems, the optimal design will use Astra as the planner, reviewer or escalation tier while lower-cost models handle routine subtasks.

Rate limits by API usage tier

The official model card lists the following limits:

• Usage tier: Free — Requests per minute: Not supported — Tokens per minute: — — Batch queue limit: —
• Usage tier: Tier 1 — Requests per minute: 500 — Tokens per minute: 500,000 — Batch queue limit: 1,500,000
• Usage tier: Tier 2 — Requests per minute: 5,000 — Tokens per minute: 1,000,000 — Batch queue limit: 3,000,000
• Usage tier: Tier 3 — Requests per minute: 5,000 — Tokens per minute: 2,000,000 — Batch queue limit: 100,000,000
• Usage tier: Tier 4 — Requests per minute: 10,000 — Tokens per minute: 4,000,000 — Batch queue limit: 200,000,000
• Usage tier: Tier 5 — Requests per minute: 15,000 — Tokens per minute: 40,000,000 — Batch queue limit: 15,000,000,000

The model is not available in the API Free tier. Production systems should read the limits associated with their actual project rather than assuming that the catalog maximum applies immediately. Large individual prompts can also consume token-per-minute capacity quickly, even when request volume is modest.

Supported inputs, outputs and tools

Astra supports text input and output plus image input. Audio and video are not supported as native model modalities.

Through the Responses API, the model supports:

• Function calling and structured outputs
• Web search and file search
• Image generation
• Code interpreter and hosted shell
• Apply Patch and skills
• Computer use
• MCP connections
• Tool search

Fine-tuning is not supported. This means teams seeking reliable domain behavior should focus on prompt design, retrieval, tools, examples, evaluations and workflow-level controls rather than planning an Astra fine-tuning project.

The model page also lists Chat Completions as a text endpoint, but this should not be misread as feature parity: OpenAI says tool calling with Astra requires the Responses API.

Three new controls for long-running agents

Astra’s release adds three controls that are particularly relevant to complex agent systems.

1. Asynchronous tool calling

With asynchronous tool calling, the model can continue working while an application runs function or custom tools, and the results can be returned when they become available. This can reduce idle time when a workflow contains independent operations or slow external systems.

Developers still need correct dependency management. Parallelizing two independent searches is useful; starting an irreversible action before a required validation finishes is not. Applications should distinguish between operations that are safe to overlap and operations that require strict sequencing.

2. Mid-turn steering

Mid-turn steering lets an application send additional instructions while a response is in progress over WebSockets. A user or supervising system can correct a direction, add a constraint or adapt the task without discarding all work completed so far.

This is especially valuable for long agent runs, where discovering a wrong assumption after ten minutes of work is much more costly than correcting it during execution. It also changes the interface design: products should show enough live progress for users to know when intervention is useful.

3. Reasoning configuration updates

Applications can change Astra’s reasoning effort during a conversation with a configuration_update. A workflow might use low effort for routine file inspection, increase to high or max for architectural decisions, and reduce effort again for formatting.

OpenAI documents important limitations. Configuration updates are supported only by Astra in standard, single-agent mode; they cannot be combined with automatic compaction or automatic truncation, and adjacent configuration updates are rejected. The response’s reported reasoning setting may continue to show the request-level value rather than the later configuration update, so observability systems should not assume that field tells the whole story.

Migration requirements developers cannot ignore

Moving from GPT-5.x to Astra is not a drop-in model-name change.

First, Astra does not support the none reasoning level. Applications that explicitly set no reasoning must select a supported effort level or remove the incompatible configuration.

Second, Astra does not support custom temperature or top_p values, and it does not support log probabilities. Code that sends those options may fail and should be cleaned up before rollout.

Third, tool calling requires the Responses API. Teams still using tools through Chat Completions need to migrate their message and tool-state handling. This is likely the largest engineering requirement for older integrations.

Fourth, long-running workflows need deliberate context handling. Persisted reasoning, WebSockets and OpenAI compaction affect not only continuity but also how misalignment monitoring can recognize and stop a continuing conversation.

Finally, prompt caching deserves renewed attention. At Astra’s input price, stable prompt prefixes and correctly managed cache behavior can materially reduce cost. But developers should test caching with realistic multi-turn histories rather than rely on assumptions carried over from an older model.

The expanded misalignment-monitoring layer

OpenAI’s updated safety documentation provides far more operational detail than the initial release summary.

Misalignment monitoring reviews a model’s reasoning and actions asynchronously in consequential situations—for example, when an agent accesses or transfers sensitive data or performs destructive operations. It is intended to detect cases where an agent may be interpreting a user’s instructions incorrectly. A flag is a reason for review, not proof that the user violated a policy or that the agent acted improperly.

Coverage depends on the API and the way conversation context is preserved:

• Responses API requests using persisted reasoning, WebSockets or OpenAI compaction are monitored, and the system can recognize conversation continuations and block further execution.
• Responses API requests without those mechanisms are monitored and can produce webhook alerts, but the monitoring system does not automatically stop the conversation.
• Chat Completions requests are not covered by this particular monitoring system, although other safety checks still apply.

When monitoring blocks a request, the API can return HTTP 403 with the code misalignment_policy_violation. OpenAI tells developers to stop dispatching actions for that conversation, avoid automatic retries, preserve the relevant request and response records, and expose the available information to the responsible user or operator.

There is no general resume mechanism for a stopped conversation. Because the monitoring runs asynchronously, an action may already have completed before the issue is detected. A stop does not roll back earlier actions.

This is a crucial architectural point. Safety monitoring is not a transaction manager. Applications that let agents change infrastructure, move money, delete records or transmit sensitive data still need their own approval gates, scoped credentials, idempotency controls, audit logs and rollback strategies.

Safety alerts and webhooks

API projects can subscribe to the safety.alert.created webhook event. The webhook carries an alert ID rather than the complete alert. A background process can retrieve the alert using an API key for the same project with the api.safety.alerts.read permission.

OpenAI cautions that a request_paused value of true means a safety block was successfully registered; it does not guarantee that execution stopped in time or that previous effects were reversed. The alert reason may also be null, including for Zero Data Retention requests, and alert delivery is not a complete audit history.

For developers, the implementation pattern should be clear:

1. Handle misalignment_policy_violation as a terminal workflow state, not a retryable network error.
2. Stop new tool dispatches immediately.
3. Record request, response and tool-call identifiers.
4. Check whether any external operation already completed.
5. Route the incident to a human reviewer.
6. Reconcile application state before starting any replacement workflow.

What OpenAI has—and has not—disclosed about performance

OpenAI now describes Astra as state of the art in computer use, browsing, software engineering, science and professional work. The current developer guide also says Astra achieves stronger evaluation results while using substantially fewer output tokens, resulting in a lower estimated API cost per task than earlier models despite its higher per-token price.

That is a meaningful performance and efficiency disclosure, but it remains a vendor claim rather than an independently validated result. The developer guide links to additional evaluations but does not reproduce a complete numerical benchmark table or enough methodology to compare every claim across models. Teams should avoid turning the summary into invented numbers.

The responsible evaluation strategy is to test Astra on representative internal tasks. Measure completion rate, factual accuracy, tool-selection quality, recovery from failure, human review time, latency and total cost per successful outcome. For agent systems, “the model finished the run” and “the result was correct” must remain separate metrics.

What ChatGPT users should expect

OpenAI’s current ChatGPT and Codex documentation no longer displays the earlier “coming in the coming days” rollout banner. Astra now appears as a recommended model across ChatGPT web and desktop, Codex CLI, the IDE extension, Codex cloud, ChatGPT Credits and API access. Because documentation-level availability can precede account-level enablement, users should confirm access in their own model picker or workspace controls.

For individual users, Astra’s value should be most visible on complex assignments: analyzing a large set of materials, researching and producing a finished report, working through code and tests, or operating across tools. It would be wasteful to judge the model only on short conversational questions.

Business and Enterprise administrators should also consider governance before enabling broad use. More capable computer use and longer autonomous workflows increase the importance of least-privilege access, clear approval policies, data boundaries and trace retention.

A practical Astra readiness checklist

Before sending production traffic to GPT-6 Astra:

1. Confirm access. Check the model’s availability for the actual API project or ChatGPT workspace.
2. Move tool workflows to Responses. Do not assume Chat Completions tool calls will continue to work.
3. Remove unsupported parameters. Eliminate none reasoning, custom temperature, custom top_p and logprobs settings.
4. Set a cost policy. Track the 272K long-context threshold and cap accidental context growth.
5. Design model routing. Reserve Astra for tasks where its capability can justify the premium.
6. Test cache behavior. Use stable prefixes and verify savings with actual usage data.
7. Implement terminal safety handling. Treat misalignment_policy_violation as a stop, not a retry.
8. Add human approval. Require confirmation before destructive, sensitive or irreversible actions.
9. Track external effects. Record whether tool actions completed before an asynchronous stop.
10. Build representative evaluations. Measure correctness and end-to-end completion separately.
11. Test streaming failures. Handle errors that arrive after output has already started.
12. Review data residency. Remember that Astra Fast mode is unavailable with EU data residency.

The larger significance of Astra

GPT-6 Astra is best understood as part of the transition from conversational AI to operational AI. The model is being offered as a system that can sustain context, coordinate tools and complete demanding work—not simply produce a stronger paragraph or code snippet.

But greater agency makes engineering discipline more important, not less. Long context needs cost controls. Tool use needs permissions. Mid-turn steering needs transparent progress. Asynchronous execution needs dependency management. Safety monitoring needs terminal-state handling and human review. And launch claims need local evaluation.

The teams that benefit most from Astra will not necessarily be those that send it the largest prompts. They will be the ones that pair the model’s capability with good task design, selective context, explicit authority boundaries and rigorous measurement.

That is the real Astra story: a more capable model, certainly—but also a more demanding production system.

Official sources

• GPT-6 Astra model card
• Using GPT-6 Astra: model and migration guidance
• OpenAI API pricing
• OpenAI API changelog
• ChatGPT and Codex model guidance
• Misalignment-monitoring documentation
• Asynchronous tool calling
• Mid-turn steering

Editor’s note: Product access and rollout language can change quickly. This article was updated on September 5, 2026, using official OpenAI documentation; account-level availability may still vary.