OpenAI · GPT-6 · September 2026
GPT-6 Astra: ChatGPT's New Model, Features, Pricing & Availability
GPT-6 Astra is OpenAI's new flagship model for difficult end-to-end work: complex reasoning, software engineering, computer use, research, document creation and long-running agentic tasks. This guide separates the launch claims from the practical details developers and ChatGPT users actually need.
What is GPT-6 Astra?
GPT-6 Astra is OpenAI's flagship GPT-6 model. OpenAI describes it as its most capable model for the hardest end-to-end work and highlights performance in computer use, browsing, software engineering, cybersecurity, science and professional tasks.
That positioning matters because modern AI workloads are changing. The important question is no longer only, “Can the model answer this prompt?” Increasingly, the question is, “Can the model understand a goal, plan multiple steps, interact with tools, recover from failures and finish the work?”
Astra is designed around that second category. It can still generate text, analyze images and answer questions, but its headline value is in difficult workflows where reasoning and execution must continue across many steps.
OpenAI's launch material reports very high scores on several frontier evaluations, including 98% on FrontierMath Tier 4, 99.9% on ARC-AGI-3 and 100% on ExploitBench. Benchmark results should not be treated as a guarantee for every real-world task, but they illustrate where OpenAI believes the biggest capability jump has happened.
The most important GPT-6 Astra features
The most useful way to understand Astra is to group its capabilities into practical categories rather than treating it as one giant benchmark number.
1. Stronger complex reasoning
Astra is built for problems that require more than a quick response. The API supports multiple reasoning-effort levels: low, medium, high, xhigh and max. Developers can therefore trade latency and cost against deeper reasoning depending on the task.
For example, a simple data-format transformation probably does not need maximum reasoning. A difficult architecture review, multi-file migration plan or complex research synthesis might.
2. Better computer and browser use
OpenAI emphasizes computer use as a major strength. This is important for agentic systems because the model can work with interfaces that do not expose a clean API. Instead of only telling a user which buttons to press, an agentic system can potentially navigate an application, inspect a page, fill forms and continue the workflow.
For businesses, this expands the set of automatable tasks. Older automation systems often require brittle selectors or custom integrations. A capable multimodal model can reason about the state of an interface and adapt when the screen changes.
3. Long-horizon task execution
Astra is aimed at tasks that may take many model turns and tool calls. Long-horizon capability is especially useful for research, coding, data analysis and operational workflows where the model must keep track of intermediate state rather than producing a single answer and stopping.
4. Coding and software engineering
OpenAI lists software engineering among Astra's strongest use cases. For developers, that can include understanding large repositories, planning refactors, debugging across multiple files, implementing features, running tools and iterating after tests fail.
The key improvement is not merely code generation. Production software work is a feedback loop: inspect, reason, edit, run, diagnose, revise. Models that perform well across the entire loop are more valuable than models that only produce a plausible first code snippet.
5. Research and document creation
Astra is also positioned for research and professional document work. A larger context window lets it consume more source material at once, while agentic tool use can help gather information, compare sources and build finished outputs.
GPT-6 Astra has a 1.05 million-token context window
OpenAI's API documentation lists a 1,050,000-token context window and up to 128,000 output tokens for GPT-6 Astra.
Context window is the amount of information a model can consider in one request, including instructions, conversation history, uploaded or retrieved text, tool messages and other input. A context window above one million tokens opens interesting possibilities for large codebases, long legal or technical documents, research corpora and extended agent sessions.
But a huge context window does not mean you should blindly send everything to the model. Large prompts increase cost and can make information retrieval less precise if the input is poorly organized. OpenAI also states that prompts above 272,000 input tokens are billed at higher rates for Astra.
Why Astra matters for AI agents
The AI industry has been moving from chat interfaces toward agents: systems that combine a model with tools, state, memory, permissions and an execution loop. Astra fits directly into that trend.
A typical agent loop looks like this:
goal = get_user_goal()
state = load_context()
while not finished:
decision = model(goal, state, tools)
if decision.requests_tool:
result = execute_validated_tool(decision.tool_call)
state.append(result)
else:
finished = True
return final_resultA stronger model can improve several parts of this loop: choosing the right tool, understanding tool results, noticing when a plan is failing, deciding when to ask the user for permission and knowing when the task is actually complete.
That said, a more capable model does not remove the need for application engineering. Authentication, authorization, financial limits, destructive-action confirmation, data validation and business invariants should still be enforced by deterministic software.
If you are building agents, see my guides on LLM vs AI agent, function calling for AI agents and agent architecture.
What GPT-6 Astra changes for coding
For coding, the most interesting shift is toward repository-level and task-level execution. Developers increasingly want an AI system to understand an issue, inspect the codebase, make coordinated changes, run tests and explain the result.
Astra's larger context and stronger computer/tool use make it better suited to this kind of work than a model optimized only for short conversational answers.
Practical tasks where Astra may be valuable include:
- large refactors that span many modules;
- debugging issues that require reading logs, source code and configuration together;
- dependency migrations and framework upgrades;
- security reviews and defensive code analysis;
- writing tests, running them and iterating on failures;
- researching unfamiliar libraries while modifying an existing codebase;
- producing technical documentation from implementation details.
For everyday autocomplete, tiny scripts or short questions, however, the most powerful model may be unnecessary. Cost and latency still matter.
GPT-6 Astra API pricing
OpenAI currently lists standard GPT-6 Astra API pricing as:
| Token type | Price per 1M tokens |
|---|---|
| Input | $10.00 |
| Cached input | $1.00 |
| Cache writes | $12.50 |
| Output | $50.00 |
OpenAI states that prompts with more than 272K input tokens are charged at 2× input and cache rates and 1.5× output rates for the full request. Batch and Flex are listed at 50% of standard rates, while Fast mode is priced at 2× the applicable rates.
That makes optimization important. A long-running agent can make multiple calls and accumulate a large conversation history. Without careful caching and context management, the expensive part is not only the first prompt; it is repeatedly sending and generating large amounts of text throughout the workflow.
A simple cost example
Suppose one request uses 100,000 uncached input tokens and generates 10,000 output tokens:
Input: 0.1M × $10 = $1.00
Output: 0.01M × $50 = $0.50
Total: $1.50This is only a simplified token example. Real agent cost may also include additional calls and paid tools such as web search or computer use.
Who can use GPT-6 Astra in ChatGPT?
As of September 5, 2026, Astra is in a staged rollout rather than instantly appearing for every account.
OpenAI says GPT-6 Astra is rolling out to a limited set of organizations first and will expand to ChatGPT Plus, Pro, Business and Enterprise users over the following days. It is also being made available through the OpenAI API, Microsoft Azure and AWS Bedrock.
Plan details are not identical. OpenAI's help documentation says Astra usage draws from existing Work and Codex allowances, with more extensive access on higher tiers. Enterprise administrators may also need to enable Astra in workspace settings.
So if you have a supported paid plan but do not see Astra immediately, that does not necessarily mean your plan is excluded. Rollouts can be account- and workspace-dependent.
GPT-6 Astra vs GPT-5.6 Sol
Astra does not make GPT-5.6 Sol useless. The better choice depends on the job.
| Area | GPT-6 Astra | GPT-5.6 Sol |
|---|---|---|
| Best fit | Hard end-to-end work and long agentic tasks | Fast high-quality everyday reasoning and conversation |
| Context | Up to 1.05M tokens | Smaller than Astra |
| Computer use | Flagship capability | Capable, but Astra is positioned above it |
| Complex coding | Best for difficult repository-level workflows | Strong for common development tasks |
| API input price | $10 / 1M tokens | Lower than Astra |
| API output price | $50 / 1M tokens | Lower than Astra |
| When to choose | Capability is the bottleneck | Cost, speed and interactivity matter more |
A useful engineering strategy is model routing. Use a cheaper model for classification, extraction, formatting and simple conversational turns, then route only genuinely difficult jobs to Astra.
Why Astra's cybersecurity safety controls are a major part of the launch
Astra is notable not only for capability but for the safeguards OpenAI says were required to release it. OpenAI classifies GPT-6 Astra as its first model to reach the Critical cybersecurity capability threshold under its Preparedness Framework.
According to OpenAI's system card, this means the model can, under the right conditions, identify previously unknown security vulnerabilities and develop new exploitation methods across hardened systems without a human directing every individual step.
That is why the public launch includes stronger controls: model-level refusals, automated misuse monitoring, additional misalignment monitoring, stricter deployment protections and restricted access to some higher-risk cybersecurity capabilities.
OpenAI also reports that Astra is more robust against prompt injection than GPT-5.6 Sol and is less likely to take unauthorized or destructive actions in browsing and workplace settings.
These safeguards matter for normal developers too. As agents gain permission to browse, run code and interact with business systems, prompt injection becomes an application-security problem, not merely a model-quality problem.
How developers should approach GPT-6 Astra
The biggest mistake would be replacing every existing model call with Astra simply because it is newer. A better architecture selects the model based on task difficulty.
Use Astra when:
- the task requires deep multi-step reasoning;
- the model must understand a very large body of context;
- the workflow requires browser or computer interaction;
- repository-scale coding quality matters more than raw token cost;
- the agent has to plan, execute, observe and recover over many steps;
- the cost of a wrong answer is higher than the extra model cost.
Use a smaller or cheaper model when:
- you are classifying text into a few categories;
- you need high-volume extraction or transformation;
- the answer is short and latency-sensitive;
- the task can be solved deterministically;
- you are processing millions of similar requests where unit economics dominate.
Recommended production pattern
if task.is_simple:
model = cheaper_fast_model
elif task.needs_large_context or task.needs_long_horizon_execution:
model = "gpt-6-astra"
else:
model = balanced_modelThen add hard controls around side effects. The model may recommend or request an action, but your application should verify permissions and constraints before executing it.
Is GPT-6 Astra AGI?
OpenAI executives have described Astra as a possible milestone toward an AGI era, but “AGI” has no universally accepted technical threshold. Strong benchmark scores and impressive computer-use performance do not by themselves settle the question.
For developers and businesses, the more useful question is measurable: which workflows can the model reliably complete, at what cost, with what supervision and with what failure rate?
If Astra can complete a larger fraction of real digital work with less human intervention, that is economically important regardless of which label the industry uses.
Frequently asked questions
Is ChatGPT Astra the same as Google Project Astra?
No. GPT-6 Astra is OpenAI's GPT-6 model. Google Project Astra is a separate Google DeepMind research project focused on universal multimodal AI assistants. The similar name makes this an easy source of confusion.
Is GPT-6 Astra free?
OpenAI's current rollout information names Plus, Pro, Business and Enterprise plans and API access. Free-tier availability has not been announced in the same rollout language, so users should check the ChatGPT model picker and official plan documentation for current access.
What is the GPT-6 Astra API model name?
OpenAI documents the model ID as gpt-6-astra.
Does GPT-6 Astra support images?
Yes. OpenAI's model documentation lists text and image input with text output. Audio and video are not listed as directly supported model modalities for Astra in the API model page at launch.
What is Astra best for?
OpenAI recommends Astra for difficult end-to-end work such as complex reasoning, coding, computer use, research and document creation. For simple, high-volume tasks, a cheaper model may be more efficient.
Does a one-million-token context window eliminate RAG?
No. Retrieval-augmented generation is still useful for selecting fresh and relevant information, controlling cost and keeping prompts focused. Large context lets you include more evidence when needed; it does not remove the value of good retrieval.
Final takeaway
GPT-6 Astra represents the direction frontier models are moving: away from isolated prompt-and-response interactions and toward sustained digital work. Its large context window, stronger coding and computer-use capabilities, long-horizon reasoning and agentic design make it particularly interesting for developers building systems that must actually execute tasks.
At the same time, Astra is more expensive than smaller models and powerful enough to require unusually strong safeguards. The winning production architecture will probably not be “Astra everywhere.” It will be a routed system that uses Astra when capability is genuinely the bottleneck and cheaper models or normal software everywhere else.