GPT-6 Astra Guide: OpenAI's Flagship, Priced Per Task

GPT-6 Astra is the model OpenAI's models page suggests as the starting point for complex reasoning and coding, and its model page calls it the most capable model for the most demanding work. OpenAI released it on 3 September 2026, and its per-token price is high enough that the first reaction of most teams is to look for a reason not to use it.

That reaction is reasonable, but it starts from the wrong number. OpenAI's pitch for Astra is not a cheaper token. It is fewer tokens per finished task. Whether that holds for your work is the only question that decides whether Astra is expensive.

The specification sheet

From OpenAI's model page:

• Price — $10 per million input tokens, $1 cached, $50 per million output. Cache writes are billed at 1.25 times the uncached input rate.
• Window — 1,050,000 tokens in total, with input capped at 922,000 and output at 128,000
• Modalities — text and image in, text out
• Knowledge cutoff — 30 April 2026
• Reasoning effort — low, medium, high, xhigh and max. There is no none; sending it returns an HTTP 400.
• Tools in the Responses API — web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP and tool search

Two surcharges matter. Prompts over 272,000 input tokens pay twice the input and cache rates and one and a half times the output rate, applied to the full request. Fast mode doubles the applicable rates. In the other direction, Batch and Flex are half the standard price.

Price per token versus price per task

OpenAI's GPT-6 guide claims that, compared with earlier models, Astra reached stronger results in several evaluations using substantially fewer output tokens, and that its estimated API cost per task came out lower despite the higher per-token price. That is a vendor claim about vendor evaluations, and it is precisely the kind of claim you should verify rather than repeat.

The mechanism is plausible, though. On a reasoning model, output tokens, including hidden reasoning, dominate the bill. A model that reaches the answer in fewer turns, with less wandering, can cost less per completed task than a cheaper model that needs three attempts and a long trace. The opposite is also possible on simple work, where a smaller model finishes in one pass and the flagship's price is pure overhead.

The way to find out is to stop comparing rate cards and compare cost per passed task on your own workload. Cost-adjusted model scoring lays out the method.

Behaviour changes that will bite an existing agent

OpenAI's migration notes list several ways Astra behaves differently from earlier models. None of them are bugs, but each one can make an existing agent look worse until you adjust for it.

• It takes instruction files more seriously. Astra is more sensitive to instructions in skills and files such as AGENTS.md. A stale or contradictory line that older models ignored may now be followed. Audit those files before you judge the model.
• It asks more questions. It is more likely to ask for clarification where earlier models assumed. Good for interactive work, disruptive for unattended runs. OpenAI's guide includes initiative and follow-through prompts for agents that keep pausing for approval.
• It formats more. It tends towards lists, tables and Markdown. If downstream code expects terse output, say so.
• It delegates less. It may hand work to subagents less often than you want. If your architecture relies on fan-out, prompt for it explicitly.
• Sampling parameters go. With reasoning on, remove temperature, top_p and logprobs options.

OpenAI also says Astra stays more coherent over long tasks, which is the property that matters most for long agent loops and the hardest to see in a short evaluation. Test with tasks long enough to expose drift.

New API surface worth using

The GPT-6 family adds a few capabilities that change how agents can be built, not just how well they score:

• Async tool calling. Mark a function or custom tool with async: true and return its result later using the original call_id. Slow tools no longer have to block the turn.
• Mid-turn steering. Send new instructions while the model is working. Over WebSocket, completed work is preserved rather than discarded.
• Effort changes without breaking the cache. A configuration_update input item changes reasoning effort mid-conversation without altering the prompt prefix, so cached input stays valid.

The last one matters more than it looks. At $10 per million uncached and $1 cached, keeping a long agent prefix in cache is a tenfold difference on input, and anything that preserves it across a session is worth designing around. Astra also supports pro reasoning mode, covered in the Sol context in the GPT-6.1 Sol Pro guide.

When Astra is the wrong default

OpenAI's own description of GPT-6.1 Sol is near-Astra performance at a lower cost, and its list price is a fifth of Astra's. For a large share of everyday coding and document work, that is the better starting point.

A workable rule:

• Default to Astra for long unattended agent runs, computer use, research tasks where a wrong conclusion is expensive, and work where you have measured Sol failing.
• Default to Sol for interactive coding, routine document work and anything high-volume, and escalate to Astra on validator failure.
• Use the batch route for evaluation sweeps and offline jobs. OpenRouter lists openai/gpt-6-astra:batch at $5 input and $25 output per million tokens at the time of writing, the same model at half price in exchange for asynchronous delivery.

Whichever you choose, set max_output_tokens with room for reasoning, watch for the 272K surcharge on long prompts, and track cost per completed task rather than cost per token. That is the number OpenAI is making its case on, and the one that will tell you whether the case holds for you.