GPT-6 Astra costs $10 per million input tokens and $50 per million output tokens on the OpenAI API, but access is still rolling out: OpenAI says it starts with limited organizations and expands to API users and paid ChatGPT plans over the coming days.
That distinction matters. The launch language is big, as it usually is with these launches. “Smartest model,” “state of the art,” “aligned,” “computer use,” “cybersecurity,” “professional work.” Fine. But for developers, the useful question is more concrete: can you call it, how much does it cost, what does it support, and what changes inside Codex?
As of September 4, 2026, Astra is not just a research announcement. OpenAI already has a model page for gpt-6-astra, a pricing table, endpoint compatibility, context limits, and a migration guide. That makes it a real platform object, even if access is still gradual.
When will GPT-6 Astra be available in the API?
GPT-6 Astra starts rolling out to limited organizations, with broader API access over the following days.
OpenAI’s launch post says Astra is available starting today for a limited set of organizations and will arrive over the coming days in the OpenAI API, Microsoft Azure, AWS Bedrock, and the ChatGPT Plus, Pro, Business, and Enterprise plans. The developer documentation phrases it similarly: API and paid-plan access arrives over the coming days.
That leaves developers with the right posture: check your account, don’t assume your organization already has it, and treat any availability note in this article as time-sensitive.
This is the part of the rollout that will age fastest. The model can appear in the documentation before it is enabled on every account.
How much does GPT-6 Astra cost?
GPT-6 Astra costs $10 per million input tokens and $50 per million output tokens at OpenAI’s Standard API pricing.
The official model page also lists cached input at $1 per million tokens and cache writes at $12.50 per million tokens. OpenAI says prompts with more than 272K input tokens are priced at 2x for input and cache rates, and 1.5x for output for the entire request. Batch and Flex cost 50% of Standard rates, while Fast mode costs 2x the applicable rate.
That puts Astra in a different category from the cheap default models for code. You don’t evaluate it with the question “can it answer programming questions?” You evaluate it on whether it lowers the total cost of the task: fewer failed attempts, fewer review cycles, fewer context resets, fewer handoffs, and less human cleanup.
OpenAI makes that argument directly in its model guide: it says Astra can deliver a lower estimated cost per task in the API, despite a higher per-token price, because it uses substantially fewer output tokens across several evaluations. That claim is OpenAI’s evaluation framing, not an independent benchmark.
Which model ID should developers use?
Developers should use gpt-6-astra as the model ID.
OpenAI’s guide says that to build with Astra, you set model to gpt-6-astra in a Responses API request. The model page also lists gpt-6-astra as an available alias/snapshot.
That small detail matters because launch articles often mix three different things: a product label in ChatGPT, a marketing family name, and the actual API identifier. Here, the documentation publishes the concrete model ID.
Which endpoints does GPT-6 Astra support?
GPT-6 Astra supports the major OpenAI endpoints, including Responses, Chat Completions, Realtime, Assistants, and Batch.
The most important practical note is that Astra supports the Responses API tool stack. The model page lists support for web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP, and tool search when using the Responses API. The same spec sheet also marks fine-tuning as not supported as a model feature.
For development workflows, that’s the real story. Astra is not just a text model with better benchmark numbers. OpenAI is positioning it as a model for agentic work across code, browser, files, shells, patches, and external tools.
That connects directly to the broader shift we’ve been tracking at yoDEV: coding models are becoming workflow operators, not just code generators. The question is no longer just “which model writes better TypeScript?” It’s “which model can survive the whole task without losing the thread?”
What changes in Codex with GPT-6 Astra?
In Codex, the most interesting claim about Astra is context persistence across long work sessions.
OpenAI says Astra introduces a new way for Codex to preserve and recover context when the context window fills up. Historically, long agentic sessions relied on compaction: the system summarizes earlier work so the model can keep going. That helps, but summaries can lose details about fixes that failed, test behavior, requirements, or why an earlier approach was ruled out.
With Astra, OpenAI says Codex can keep notes across context windows and search earlier windows to recover requirements, test results, and tool outputs, even when those details weren’t captured in the notes. OpenAI says this experimental feature can be enabled in Codex’s config.toml and will become the default for Astra in the coming weeks.
That last sentence needs a date. As of September 4, 2026, OpenAI describes it as experimental and not yet default behavior.
For large refactors, this could matter more than another benchmark win. A coding agent’s failure mode often isn’t ignorance. It’s drift. It forgets that a test already failed, loses a constraint from forty minutes ago, or treats a steering message as a new task. If Astra really reduces that drift on real projects, the value shows up as fewer restarts and cleaner handoffs.
Is GPT-6 Astra better for coding?
OpenAI says GPT-6 Astra is its best software engineering model yet, but the evidence still comes mainly from OpenAI’s launch data and partner quotes.
The official post presents Astra as outperforming GPT-5.6 Sol on several coding and agent evaluations. It lists Terminal-Bench 4.0 at 57.9% for Astra versus 37.3% for GPT-5.6 Sol, DeepSWE v1.1 at 74.1% versus 72.7%, and internal database migration tasks at 63.9% versus 42.7%.
Those numbers are useful, but they don’t mean “your repository will improve by X.” Development teams should test Astra on their own mix of tasks: bug fixing, migrations, test repair, frontend QA, browser workflows, security review, and long changes that usually exhaust the context.
The strongest reason to test Astra isn’t any single score. It’s the combination of coding, computer use, tool support, long context, and memory behavior in Codex.
What does GPT-6 Astra mean for cybersecurity?
GPT-6 Astra represents a major leap in cybersecurity according to OpenAI, which makes it useful for defenders and more sensitive to deploy.
OpenAI says Astra reaches its “Critical” cybersecurity threshold under its Preparedness Framework. The company reports strong results on exploitation and reverse engineering evaluations, including internal tests with recent vulnerabilities. It also says Astra discovered and used two previously unknown zero-day vulnerabilities during evaluation, and that OpenAI is disclosing them to their maintainers.
For day-to-day developers, the practical implication is narrower: Astra should be relevant for secure code review, patching, and defensive workflows, but OpenAI says it will refuse more advanced cybersecurity tasks, such as building proof-of-concept exploits for vulnerabilities.
This matters for engineering leaders. A model that is significantly better at developing exploits is also a model that needs stronger policies, logging, review, and access control within teams. OpenAI says additional safety controls may pause or stop some tasks, including legitimate defensive work. In the API, the task may be stopped.
That’s not a footnote. It’s part of the product’s behavior.
Should you switch to GPT-6 Astra right away?
Developers should test GPT-6 Astra first on high-value agentic work, not blindly replace cheaper models everywhere.
At $10 per million input tokens and $50 per million output tokens, Astra has to earn its place. The obvious first workloads aren’t short completions or simple chat. They’re expensive human loops: repository migrations, investigating flaky tests, multi-file refactors, browser-based QA, secure code review, long debugging sessions, and tasks where earlier agents lose context.
For many teams, the winning setup will probably be tiered: cheaper models for routine work, Astra for tasks where reliability and context retention justify the premium.
That’s the real story of the launch. OpenAI isn’t just dropping another model name. It’s pushing the frontier model deeper into the agentic harness: memory in Codex, computer use, hosted tools, patches, browser work, and cybersecurity-sensitive deployment.
The AGI language will grab the headlines. The API bill and the behavior in Codex will decide whether developers keep using it.