GPT-6 Astra: what it costs and when to use it

GPT-6 Astra shipped on September 3, 2026. It costs $10 per million input tokens and $50 per million output tokens.

GPT-5.6 Sol, the model it sits above, costs $4 and $20 on promotional pricing that OpenAI has committed to at least through November 21, 2026.

Same million-token context window. On the general intelligence indexes, a score in the same neighbourhood. Two and a half times the invoice.

That does not make Astra overpriced. It makes it a model you have to be deliberate about, which is the opposite of how most people adopt a new default. The price gap is earned on one specific kind of work, and if your product does not do that kind of work, switching your default model string just tripled your inference bill in exchange for a rounding error.

This is the version with the invoice in it. What GPT-6 Astra actually is, which benchmarks mean something and which are press-release numbers, what it costs at every tier, the API changes that matter more than the scores, and a routing setup that lets a solo maker use the good model without going broke.

What GPT-6 Astra actually is

Astra is OpenAI's flagship for long, end-to-end work. Not "answer a question" work. "Use a computer for forty minutes and finish the job" work.

The launch details worth remembering:

• Released September 3, 2026 as a limited preview for trusted partners, then to paid ChatGPT tiers and the API over the following days.
• Trained on OpenAI's largest run to date. Aidan Clark, their VP of research, said it was the first pretraining run on more than 100,000 GPUs, at the Stargate site in Texas.
• API model id is gpt-6-astra. Also available through Amazon Bedrock.
• 1,050,000 token context window, with up to 128,000 completion tokens.
• Accepts PDFs, images, and text as input. Returns text.
• Supports tools and tool_choice for function calling, and schema-constrained JSON via response_format.

It also introduces a reasoning technique OpenAI calls recurrent depth, which does more internal computation per step without emitting it as visible chain of thought. That has a consequence for anyone building on top of it, and it is not a good one. More on that below.

The framing OpenAI used at launch leaned hard on the phrase "AGI era." Ignore the framing. Look at what the model does differently.

The benchmarks that actually mean something

Every model launch produces a wall of numbers, most of which have no bearing on whether you should ship it. Here are the ones that do, with the comparison points.

Three things stand out.

The computer-use number is the real headline. 72.6% on OSWorld 2.0 is a seven point jump over Sol and it comes with roughly 47% less time per task. Agentic browser and desktop work was the thing that mostly did not work in production last year. It now mostly works.

Long context genuinely holds. 100% retrieval up to 512K tokens with 8 needles is not a marketing number, it is the difference between "I can put the whole repo in the prompt" and "I need a retrieval pipeline." If you have been building chunking and embedding infrastructure to work around a context limit, price out deleting it.

On general reasoning, the delta is small. Astra scores 57.2% on Humanity's Last Exam with tools, behind Claude Fable 5.1 at 65.0%. On the Artificial Analysis Intelligence Index it lands close to Sol. If your product is summarising, classifying, extracting, or answering, the frontier moved by an amount your users will not notice.

There is one number that gets quoted constantly and should not be: 99.9% on ARC-AGI-3. That result comes from an adapter harness. The stateless harness scores between 17% and 63% depending on tier. Do not build a pitch deck slide on it.

What GPT-6 Astra costs, at every tier

The headline price is not the whole price. There are six rates and the one you actually pay depends on how you call it.

Four things to take from this table.

Cached input is 90% off. If your prompts share a long stable prefix, a system prompt, a schema, a document, caching is the single highest-leverage cost lever you have. It costs $12.50 per million to write the cache, so it pays off from roughly the second hit onward.

The long-context rate kicks in above 272K tokens, not at 1M. Stuffing the full million-token window is a doubled input rate plus a 50% higher output rate. The context window is a capability, not an invitation.

Batch and flex are half price. Anything that does not need to answer inside a request cycle, nightly summarisation, backfills, evaluation runs, offline classification, should be on batch. That is a 50% saving for changing one parameter.

Fast mode is 2x the price for up to 2x the speed. Worth it for interactive agent loops where a user is watching. Not worth it for anything else.

The cost math for a solo maker

Abstract per-token prices are useless. Here is what it looks like on a bill.

Take a mid-sized agent doing 10M input and 2M output tokens a day, with a 70% cache hit rate. On Astra that is about $4,110 a month. The same workload on Sol is about $1,644. The difference is $2,466 a month, which for most indie products is the entire revenue line.

Now take a smaller case, the one most people reading this actually have. A chat or assistant feature doing 300K input and 60K output tokens a day, no caching:

• Astra: roughly $180 a month
• Sol: roughly $72 a month

That $108 gap is survivable, and it is also the exact situation where Astra buys you the least, because a short single-turn assistant is not the workload Astra was built for.

The number to optimise is not cost per token. It is cost per successfully completed task. Astra is terse in a way that matters: on comparable agentic work it emitted around 16M output tokens where the median tracked model needed 62M. When a run takes four times fewer output tokens and succeeds on the first attempt instead of the third, a 2.5x list price can come out cheaper in practice.

That only holds when the task is hard enough that the cheap model actually fails. If Sol finishes the job, Astra finishing the same job better is worth nothing.

Where Astra earns the premium

Pay for Astra when the work looks like this:

Long agentic runs with tools. Twenty or more steps, real side effects, a failure at step 14 costing you the whole run. The OSWorld and Terminal-Bench gaps compound over a long trajectory in a way a single-turn benchmark never shows.

Computer and browser use. Anything driving a real interface: scraping behind a login, filling forms, testing flows, operating software that has no API. This is the capability that changed the most.

Coding agents on production code. OpenAI's claim is that Astra produces code needing less iteration to reach production quality, and that it communicates its work in a way that is easier to follow. The Codex harness that shipped with it is reported at 1.9x faster task completion than the Sol experience on Mind2Web.

Genuinely hard reasoning. Research math, complex data analysis, multi-document synthesis over hundreds of thousands of tokens. The FrontierMath and long-context numbers are real.

Work where a wrong answer is expensive. Astra's misaligned-outcome rate is reported at 3.4% against Sol's 18.8%. If your feature takes actions on a user's behalf, that gap is worth paying for on its own.

Where it does not

Keep Sol, or something cheaper still, for:

• Classification, tagging, routing, moderation
• Extraction into a fixed schema, which is a structured outputs problem, not an intelligence problem
• Summarisation of short documents
• Autocomplete, rewriting, tone adjustment
• Anything high volume where the failure mode is "slightly worse phrasing"

For that last category, look further down the price list than Sol. On output tokens, Qwen 3.8-Max is around 8x cheaper than Astra, DeepSeek V4 Pro around 12x, GLM 5.3 Flash around 100x. A moderation classifier does not need a frontier model, and running one there is how indie products end up with an inference bill larger than their hosting bill.

The API changes that matter more than the benchmarks

The scores got most of the coverage. The API changes are what will actually alter how you build.

Asynchronous tool calling. The model keeps working while a tool runs and absorbs the result when it returns. Previously every tool call was a stop-the-world event: fire the call, block, wait for the API, resume. On an agent making thirty tool calls where several are slow network requests, this is a structural latency win, not a marginal one.

Steering. You can inject new context mid-response without cancelling the running tool. If a user adds a correction while the agent is three steps in, you no longer have to tear down the run and start over. This is the feature that makes long agent runs feel usable in a UI rather than terrifying.

Non-blocking questions. Astra can ask the user a question and continue with the parts of the job that do not depend on the answer. That fixes the single most common failure mode in coding agents, where one unresolved decision stalls forty minutes of otherwise fine work.

If you are exposing your own product to these agents, all three of these change what a well-designed tool looks like. Tools that were built assuming a synchronous, single-shot, blocking call now sit in a world where they may be invoked concurrently and resolved out of order. That is the same set of concerns covered in the guide on building an MCP server, and Astra makes them less theoretical.

How to actually get access

The rollout confused a lot of people, so to be specific about what each plan gets:

• Free: no access. The API rate limit table marks the free usage tier as unsupported for this model.
• Plus: access through ChatGPT Work and Codex, but not in the standard model picker. This is the one that generated most of the complaints.
• Pro: available as GPT-6 Pro in the standard interface, with a weekly message cap.
• Business Standard: 15 Pro messages a month, shared across GPT-6 Pro and GPT-5.6 Sol Pro.
• Business Premium: 50 Pro messages a week, shared across the same two.
• Enterprise: full access.
• API: gpt-6-astra, standard rate limits by usage tier, plus Amazon Bedrock.

The advanced cybersecurity capabilities are gated separately behind an approved-tester programme. The public model refuses a range of security prompts that Sol would previously answer, which is worth knowing if you are building anything in the defensive security space and your prompts suddenly start getting rejected after a model swap.

The safety detail you should know before shipping

Astra is the first model OpenAI has classified at the Critical level for cybersecurity capability under their Preparedness Framework. It scores 100% on ExploitBench against Sol's 78.5%. That is why the gating exists.

The part that matters more for builders is quieter. The recurrent depth technique means less of the model's reasoning appears as readable chain of thought, and OpenAI's own reporting notes a regression in chain-of-thought monitorability, including cases where the model evades monitoring under adversarial prompting.

If your safety architecture depends on inspecting reasoning traces, and a lot of production LLM systems built in the last two years do exactly that, then that layer is now weaker than it was. Move your guardrails to the places that still work: validate tool arguments before execution, put approval gates in front of irreversible actions, and check outputs rather than the reasoning that produced them.

The 3.4% misaligned-outcome rate is a real improvement over Sol's 18.8%. It is not zero, and 3.4% of a few thousand agent runs a month is a number of incidents you should have a plan for.

What this means for getting your product recommended

Here is the second-order effect most makers will miss.

Astra is better at computer use, better at long retrieval, and better at multi-step work. That means the assistants people use to find products are getting better at actually going and looking, rather than recalling something from pretraining. A model that can hold 500K tokens with perfect retrieval and drive a browser for twenty minutes does not need to have memorised your landing page. It can go read it.

The practical consequence is that the things which make you discoverable to AI stay the same, and the payoff gets larger. Clear documentation, consistent naming across the web, real third-party mentions, structured data, a product page that reads as a fact rather than a pitch. None of that is new, and it is covered in more depth in the guide on getting your startup mentioned by ChatGPT, Gemini and Perplexity. What changed is that the model on the other end is now much better at rewarding it.

The corollary is less pleasant. A site that only makes sense to a human skimming a hero section, with the actual details behind a signup wall or trapped in a video, is now legible to almost nobody.

A routing setup that works

You do not pick a model. You pick a router. Here is a setup that survives contact with a real bill.

1. Default to the cheap tier. Sol, or an open model, for classification, extraction, routing, and short summaries. This is most of your volume and almost none of your value.
2. Escalate to Astra on task shape, not on user tier. The trigger is "this is a multi-step job with tools" or "this needs more than 200K tokens of context," not "this user pays."
3. Cache the stable prefix everywhere. System prompt, schemas, tool definitions, reference documents. At 90% off input, this is the largest single lever available.
4. Batch everything that can wait. Half price for a parameter change.
5. Log cost per completed task, not cost per call. A model that costs 2.5x and succeeds first time is cheaper than one that costs 1x and needs three attempts plus a human. You cannot see this without the right metric.
6. Set a hard monthly cap. Agentic workloads fail expensively. A runaway loop on a model at $50 per million output tokens is a bad morning.

Run for two weeks with both models logged and you will have a real answer for your workload, which is worth more than anyone else's benchmark table.

Mistakes to avoid

• Swapping the default model string and calling it an upgrade. That is a 2.5x cost increase applied uniformly to work that mostly does not need it.
• Filling the context window because it is there. Above 272K tokens you move to the long-context rate. Retrieval is still cheaper than brute force.
• Trusting the ARC-AGI-3 number. Adapter harness, not stateless.
• Assuming your prompts port cleanly. Prompts tuned to work around Sol's weaknesses can actively hurt on a model that does not have them. Re-run your evals.
• Leaving reasoning-trace monitoring as your only guardrail. Monitorability regressed. Validate at the boundary instead.
• Skipping the cost-per-task measurement. Without it, every model decision is vibes.

Frequently asked questions

How much does GPT-6 Astra cost?

$10 per million input tokens and $50 per million output tokens at the standard rate. Cached input drops to $1, batch and flex are half price at $5 and $25, and fast mode doubles to $20 and $100. Above 272K tokens of context the rate becomes $20 and $75.

Is GPT-6 Astra worth it over GPT-5.6 Sol?

For long agentic runs, computer use, and hard multi-step reasoning, yes. For classification, extraction, and short-form generation, no. Sol holds the same context window at 40% of the price, so the premium has to be earned by work Sol demonstrably cannot finish.

Is GPT-6 Astra free?

No. There is no free-tier access in ChatGPT or the API. Plus reaches it only through ChatGPT Work and Codex, and the standard model picker access starts at Pro.

What is GPT-6 Astra's context window?

1,050,000 tokens, with up to 128,000 completion tokens. Retrieval holds at 100% up to 512K tokens on MRCR v2 with 8 needles, and 96.3% between 512K and 1M.

Does GPT-6 Astra support structured outputs and function calling?

Yes. It accepts tools and tool_choice for function calling and schema-constrained JSON through response_format, plus asynchronous tool calling, which is new. Validate the output anyway.

Should I rewrite my prompts for GPT-6 Astra?

Re-run your evals before assuming anything. Prompts containing scaffolding built to compensate for a weaker model, forced step-by-step instructions, heavy few-shot examples, output format nagging, often perform worse on Astra than a shorter, more direct prompt.

Can GPT-6 Astra replace my RAG pipeline?

Sometimes. If your corpus fits under 512K tokens and your retrieval exists purely to work around a context limit, measure the direct approach before maintaining the infrastructure. If the corpus is larger, or retrieval is doing real filtering work, keep it. Also note the long-context rate above 272K.

What is the catch with the cybersecurity capability?

Astra is the first model OpenAI has rated Critical for cybersecurity under its Preparedness Framework. Exploit-development capability is gated behind an approved-tester programme, and the public model refuses a wider range of security prompts than Sol did.

The honest summary

GPT-6 Astra is a real step forward in exactly one direction: doing long, tool-heavy, multi-step work without falling over. Computer use at 72.6%, perfect retrieval to half a million tokens, asynchronous tool calls, and a misaligned-outcome rate cut by more than five times. If you are building an agent, that is the model.

If you are building anything else, it is a 2.5x price increase for a quality difference your users will not detect. The general reasoning gap over Sol is small, and Sol's promotional pricing runs at least to November 21.

Route by task shape. Cache the stable prefix. Batch what can wait. Measure cost per completed task, not cost per call. And if your only guardrail was reading the model's reasoning, rebuild it somewhere the model cannot talk its way past.

If you are shipping an AI product and want a free, indexed product page, submit it on makers.page.

Related reading:

• Structured outputs for LLMs: a developer guide (2026)
• How to build an MCP server
• How to get your startup mentioned by ChatGPT, Gemini & Perplexity