September 4, 2026 ·

openaipricingagentsenterprisestrategycoding

OpenAI says stop pricing tokens and price the task. Run the arithmetic and GPT-6 Astra has to be 5.8x more efficient to justify its own launch claim

What shipped

OpenAI released GPT-6 Astra on 3 September 2026 — the same Astra that crossed the Critical cybersecurity threshold of its Preparedness Framework the day before. The pitch is computer use: a model that operates software the way a person does, moving between spreadsheets, forms and browser tabs, including applications that expose no API at all. Microsoft’s listing describes it as able to “interact with software on a person’s behalf, move between apps, and complete multi-step tasks with appropriate human oversight.”

The framing was maximal. “Welcome to the AGI era,” Brockman said. Chief scientist Jakub Pachocki supplied the counterweight in the same launch: “Progress in intelligence does not guarantee progress in alignment.”

The specifications are checkable: a 1,050,000-token context window, 128,000 max output tokens, text and image in and text out, a knowledge cutoff of 30 April 2026, and reasoning tokens with adjustable effort from low through max. Rollout began through the Trusted Access and Daybreak programmes, with ChatGPT Plus, Pro, Business and Enterprise “in the coming days,” plus the API, AWS Bedrock and Microsoft Foundry.

The price is 2.5x, and it is 2.5x on every line

Here is the launch price sheet against the model it replaces.

Per 1M tokens	GPT-5.6 Sol	GPT-6 Astra	Multiple
Input	$4.00	$10.00	2.5x
Cached input	$0.40	$1.00	2.5x
Output	$20.00	$50.00	2.5x
Long-context input	$8.00	$20.00	2.5x
Long-context output	$30.00	$75.00	2.5x

Cache writes land at $12.50 per million, 25% above the standard input rate. Fast mode doubles everything to $20/$100; Batch and Flex halve it to $5/$25; Azure’s US data-zone deployment adds 10%, at $11/$55.

The uniformity of that right-hand column is the most useful fact in the launch. Because Astra is 2.5x Sol on input and output and cached input, the ratio between the two bills does not depend on your prompt shape: a retrieval-heavy workload at 20:1 input-to-output and a reasoning-heavy one at 1:3 face the identical multiple. That is unusual — most upgrade decisions require modelling your own token split first, the exercise Anthropic’s Fable 5.1 cache-read cut demanded days earlier. Astra hands you one number: 2.5.

It also hands you a coincidence worth noticing. $10 input and $50 output is exactly what Anthropic charges for Claude Fable 5.1, released two days earlier. OpenAI’s new flagship did not price against its own previous model; it priced against its competitor’s current one, and left the gap to Sol for buyers to absorb.

”Price per task” is a testable claim

OpenAI’s answer to the premium is that tokens are the wrong unit. Executives argued that price per task is what matters, and cited roughly 57% lower estimated API cost per task on DeepSWE v1.1 versus Sol.

That is a fair argument in principle, and it is also arithmetic. Let P be Sol’s blended price per token. Astra’s cost is 2.5P multiplied by however many tokens Astra uses. For Astra’s cost per task to land at 43% of Sol’s:

Astra tokens x 2.5P = 0.43 x (Sol tokens x P)

Which resolves to Astra using 0.172 of Sol’s tokens — about 5.8x fewer. And the break-even case, where the two models cost the same per task, still requires Astra to use 40% of Sol’s tokens, or 2.5x fewer.

So the launch claim is not “Astra is a bit more efficient.” It is that on DeepSWE v1.1, Astra reaches a better answer using roughly one-sixth of the tokens. If true, that is a more remarkable result than any benchmark on the chart.

Two things temper it. The figure is described as estimated, on one benchmark, where Astra’s 74.1% beats Sol’s 72.7% by 1.4 points. And the efficiency number that is easiest to verify points at a far smaller gain: on OSWorld 2.0, OpenAI reports Astra completing tasks in about 47% less time. A 47% cut in wall-clock time is not the same object as a 5.8x cut in tokens, and the two figures come from different benchmarks.

There is also a date on the denominator. Sol’s $4/$20 is promotional, available at least through 21 November 2026, and represents 20% off input and 33% off output against the prior rate — implying a standing rate near $5/$30. If the promotion lapses, Astra’s multiple falls to roughly 2.0x input and 1.67x output, and the break-even efficiency falls with it. Part of today’s premium is an artefact of a discount with an expiry date — the same structure Google built into every Gemini Flash release expiring on 1 January 2027.

The 1.05M window has a cliff at 272K

The context window is the launch’s most quotable number and its most misleading one. Requests above 272,000 input tokens are billed at long-context rates — $20 input, $2 cached, $75 output — and the surcharge applies to the whole request, not the excess.

The consequences are sharper than a percentage suggests. A 271K-token request costs about $2.71 in input; a 273K-token request costs about $5.46 — roughly 0.7% more context for 100% more input cost. Filling the advertised window costs about $21 in input before a single output token exists. Cached reads follow the cliff too, moving from $1 to $2 per million, so a large cached prefix does not insulate you.

For a model sold on long-horizon agent work this is backwards from where the pressure lands: agent loops accumulate context by design, and one that drifts past 272K silently doubles its own input rate. Treat 272K as the real context window and the remaining 778K as a priced escape hatch.

The launch numbers describe a harness, not an API call

Independent testing from ARC Prize found Astra’s ARC-AGI-3 result swinging from roughly 17% to 63% under a standard stateless harness depending on reasoning tier, against a marketed figure near 99% obtained with a provider adapter that preserves reasoning state between turns. Published numbers vary between outlets too — 98.6% and 99.9% both circulated on launch day for the same benchmark.

This is not the same as the benchmark being wrong — preserved reasoning state is a genuine capability, and the harness is part of the product. But the number on the chart is an upper bound achieved under OpenAI’s own scaffolding, and a plain stateless call from your code is a materially different configuration. The same benchmark makes the point twice: NVIDIA’s AVO harness lifted Claude Opus 5 from a 30% baseline to 100% without changing the model at all. Increasingly the harness is the product, which is why our agent-tooling shortlist evaluates scaffolding rather than weights.

Where Astra loses

The AGI framing does not survive contact with the full benchmark table.

• Humanity’s Last Exam (with tools): Astra 57.2% against Claude Fable 5.1’s 65.0% — the single academic row Astra loses, and the one omitted from the launch prose.
• DeepSWE v1.1: Astra 74.1%, below Meta’s Muse Spark 1.3 at 75.4%, whose contributor tier lists at $0.10/$0.20 per million tokens.
• FrontierCode 1.1: Astra 64.5%, just under Fable 5’s 64.9%.
• GDPval, OpenAI’s own measure of real-world occupational tasks, is absent from the launch materials — a conspicuous omission under an AGI headline.

Against that, the computer-use gains are real and large: 72.6% on OSWorld 2.0 versus Sol’s 65.7%, and 92.7% on ScreenSpot-Pro versus 76.9%. Astra is the strongest desktop-automation model available and is not uniformly the strongest coder — an argument for routing rather than replacement, and a reason to keep a comparison of the flagships in front of you rather than a single default.

The quieter cost: tool calling now requires the Responses API

OpenAI’s changelog carries three constraints that will cost some teams more than the price sheet does. Tool calling with Astra requires the Responses API — Chat Completions callers must migrate. Astra does not support custom temperature, top_p or log probabilities. And it does not support the none reasoning effort level.

Individually these are reasonable engineering decisions. Together they mean the portable subset of OpenAI’s API — the Chat Completions shape that every gateway, every wrapper and most multi-provider code targets — no longer reaches the flagship’s tool calling. That lands about a week after the Assistants API shutdown completed, a sequence traced in the platform layer’s half-life, and shortly after OpenAI cut Cursor’s model access. The countermeasure is unchanged: keep orchestration in your own code or behind a neutral gateway, so a call-surface change is a config edit rather than a rewrite.

What to do

Price the task, with your own tasks. OpenAI is right that cost per task is the correct unit and wrong to expect anyone to take 57% on trust. Pick your ten most expensive recurring workflows, run each on Sol and Astra, and record total tokens and completion rate. The threshold is unambiguous: Astra needs to use under 40% of Sol’s tokens to be cheaper at all.

Route, do not replace. Send long-horizon agent runs and computer-use automation to Astra; leave summarisation, extraction, classification and routine coding assistance on Sol or a cheaper tier. A 2.5x multiple applied to your whole volume is a large, avoidable cost.

Cap context below 272K. Put a hard limit in your context assembly before an agent loop finds the cliff on your behalf. If a workload genuinely needs more, size it at long-context rates from the start.

Benchmark your harness, not OpenAI’s. If your integration calls the model statelessly, the launch-chart numbers do not describe it. Measure with your own scaffolding before you promise anyone a capability jump.

Re-check availability before planning around it. Astra is rolling out through gated programmes first, with ChatGPT paid tiers following in days rather than weeks — but the cybersecurity capability stays constrained on the public version, per the Critical-threshold classification and the training pause that preceded it.

The bottom line

GPT-6 Astra is a genuine capability step on the thing OpenAI chose to lead with — a model that drives software across applications rather than answering questions about them. The computer-use numbers support that, and the argument that tokens are the wrong billing unit for agentic work is correct.

But the pricing case OpenAI made for itself is unusually falsifiable. At exactly 2.5x on every line item, Astra must consume 2.5x fewer tokens just to cost what Sol costs, and 5.8x fewer to deliver the 57% saving quoted at launch — an enormous claim resting on one estimated figure from one benchmark where the score gap is 1.4 points. The verifiable efficiency number in the same launch, 47% less wall-clock time on OSWorld, is not evidence for it.

Run the ten-workflow test. If Astra clears 40%, the upgrade pays for itself and the AGI language was underselling it. If it does not, you have a very capable model that belongs on the hard tail of your traffic and nowhere near the bulk of it.

Update, 5 September 2026 — a real cost-per-task figure, from the other lab. OpenAI’s argument that tokens are the wrong billing unit for agentic work gained an unusually well-instrumented datapoint on 4 September, and it came from Anthropic. An 11-day, dozens-of-agents formalisation of Fermat’s Last Theorem in Lean consumed roughly 6 billion output tokens — a ~$300,000 task at list rates, against roughly $2,000 for the ten open mathematical problems an internal Astra build cracked in August. Both are “one task.” They differ by about 150x, and the expensive one was the verification, not the discovery. That is the strongest available evidence that pricing the task rather than the token is the right frame — and also that the variable driving the number is how hard your output is to check, not how hard it was to produce. The full arithmetic.

Update, 6 September 2026 — the price is not the only thing that varies. The arithmetic above describes Astra’s global list rate. It is not the rate or the product a European buyer can procure. OpenAI’s model guide states that Astra does not support service_tier: "fast" or service_tier: "priority" with EU data residency, so the 2x latency tier that a US-resident deployment can escalate to does not exist for an EU-resident one — at any price. Regional processing endpoints also carry a 10% uplift, putting EU-resident Astra near $11/$55 rather than $10/$50. On Microsoft Foundry the gap is total: Astra shipped in Global and US Data Zone only, with no EU Data Zone and no published date for one. None of it appeared in the 3 September changelog. The full jurisdictional picture.

Update, 7 September 2026 — the benchmark that scored it has been rewritten. Artificial Analysis published Intelligence Index v4.2 on 4 September, days after its initial scoring placed Astra roughly level with GPT-5.6 Sol — a result that sat awkwardly against Epoch AI, which ranked Astra first across a 50-plus benchmark suite. The rewrite added two benchmarks, dropped a saturated GPQA Diamond, corrected scoring errors, and doubled private held-out test data to 40% of index weight. Astra came out four points ahead of Sol; Claude Fable 5.1 still leads overall. Two sub-scores bear directly on the arithmetic above: Astra leads the new GDP.pdf long-document benchmark at a 33.2% all-pass rate against Fable 5.1’s 26.2%, and it dominates the output-token-efficiency frontier — which is the side of the price sheet where the per-task case actually has to be won. The full picture.

Update, 8 September 2026 — the line in the system card that is not about price. OpenAI’s own safety documentation for Astra states that its monitorability has decreased relative to GPT-5.6 Sol, that the set of tasks Astra can complete without any chain of thought is “greatly expanded,” which “decreases the surface available to monitoring,” and — plainly — that “if the model were to try to sandbag covertly, we would likely be unable to catch it.” The UK AI Security Institute measured Astra’s no-CoT time horizon at 30.9 minutes against 3.6 minutes for Sol. Two things follow for anyone running the ten-workflow test above. First, CoT controllability improved sharply in the same evaluation (~93% of samples following the tested constraint, against ~48%), so instrumented reasoning-compliance metrics will look better while covering less of the work. Second, UK AISI found reasoning summaries missing on up to 80% of long trajectories through the user API — so the longer the agent run, the less of it you can see. Budget for output-level verification rather than trace inspection. The full analysis.

---

Update, 19 September 2026 — the first vertical configuration. OpenAI shipped Astra for Law on 17 September: the same GPT-6 Astra model, paired with a proprietary legal search index and domain instructions, reaching 54.0% overall correctness on 200 legal research questions against 38.7% for the base model with ordinary web search. No price has been published for either the Trusted Access tier or the forthcoming API, which matters here for the reason set out above — legal research is a long-context, high-retrieval workload, exactly the shape that makes the per-task arithmetic rather than the per-token rate the number to watch.

---

Update, 23 September 2026 — the multiple doubled and Astra never moved. The arithmetic above rests on one number: Astra costs exactly 2.5x GPT-5.6 Sol on every line item, so the price-per-task defence reduces to Astra burning ~5.8x fewer tokens, with break-even at 2.5x. That denominator changed on 22 September. OpenAI cut the mid-tier in half, shipping GPT-6 Sol at $2/$10, and left Astra at $10/$50, cached $1.00, fast mode $20/$100 — the same rate card it launched with.

Astra is now exactly 5x GPT-6 Sol on input, output, cached input and fast mode. Every threshold in the analysis above doubles: break-even alone now requires 5x fewer tokens per task, not 2.5x. Nothing about Astra’s capability changed in nineteen days; only the thing it is measured against did. Sharper still, on the AutomationBench 1.0.6 chart OpenAI chose to headline the Sol launch, Astra at low effort scores 30.3% against Sol at xhigh at 33.2% — an effort-mismatched pairing, and OpenAI’s own choice of framing. Astra’s case now rests on the narrower brief where it clearly leads: OSWorld 2.0 (72.6% vs Sol’s 60.5%) and Agents’ Last Exam (59.3% vs 56.4%). Any Astra business case written against a 2.5x premium in early September needs re-running against 5x before it reaches a signature.

Frequently asked questions

Should we upgrade from GPT-5.6 Sol to GPT-6 Astra?

Not on the launch numbers alone, and not as a blanket swap. Astra costs exactly 2.5x Sol per token on both input and output, so for any workload where Astra uses a similar number of tokens to reach the same answer, your bill goes up 150%. The upgrade pays for itself only where Astra genuinely collapses multi-step work into fewer steps — long-horizon agent runs, computer-use automation across applications that have no API, and coding tasks that Sol currently fails or retries. Those are real categories and Astra looks strong in them. They are also a minority of most teams' token volume. The disciplined move is to route the hard tail to Astra and leave the bulk on Sol, then measure cost per completed task rather than cost per million tokens for four weeks before deciding anything wider.

What is the 272K threshold and why does it matter more than the 1.05M context window?

Astra advertises a 1,050,000-token context window, but any request whose input exceeds 272,000 tokens is billed at long-context rates for the entire request — $20 per million input, $2 cached, $75 output, versus $10/$1/$50 below the line. It is a cliff, not a taper. A request with 271,000 input tokens costs about $2.71 in input; one with 273,000 costs about $5.46. Adding 0.7% more context doubles the input bill. Filling the whole window costs roughly $21 in input alone before you have generated a single output token. In practice this means the headline $10 rate does not apply to the headline 1.05M window, and any retrieval or agent loop that grows context unattended has a step function in it. Cap your context assembly below 272K deliberately, or accept that you have chosen the 2x tier.

Why do the launch benchmark numbers not match what we see from the API?

Because several of them describe a harness rather than a model. Independent ARC Prize testing found Astra's ARC-AGI-3 result ranges from roughly 17% to 63% under a standard stateless harness depending on reasoning tier, against the marketed figure near 99% obtained with a provider adapter that preserves reasoning state between turns. That is not an accusation of dishonesty — preserved reasoning state is a legitimate capability — but it does mean a plain stateless API call is a different product from the one on the launch chart. Published figures also diverge between sources, with 98.6% and 99.9% both circulating for the same benchmark, most likely different harness configurations. Treat the launch table as an upper bound achieved under OpenAI's own scaffolding, and benchmark your own harness before you budget against those numbers.

Does Astra lock us into OpenAI more than previous models did?

Somewhat, and this is the part of the launch that got the least attention. Per OpenAI's changelog, tool calling with Astra requires the Responses API — Chat Completions users have to migrate. Astra also does not support custom temperature, top_p or log probabilities, and does not support the 'none' reasoning effort level. Each of those is defensible on its own; together they mean the knobs and the call surface you standardised on for portable multi-provider code do not carry over. This lands roughly a week after the Assistants API shutdown completed, which is a reminder that OpenAI's platform layer has a shorter half-life than its models. If cross-provider portability matters to you, keep tool orchestration in your own code or behind a gateway rather than in OpenAI's API primitives, and price the migration work into any Astra adoption plan.

Is Astra actually the best model now?

It leads on most published academic and computer-use benchmarks and it is plainly a large step on agentic desktop work — 72.6% on OSWorld 2.0 against Sol's 65.7%, and 92.7% on ScreenSpot-Pro against 76.9%. It does not sweep the table. On Humanity's Last Exam with tools it scores 57.2% against Claude Fable 5.1's 65.0%, the one academic row it loses. On DeepSWE v1.1 its 74.1% sits below Meta's Muse Spark 1.3 at 75.4%, and on FrontierCode 1.1 its 64.5% sits just below Fable 5's 64.9% — both awkward for the claim that it is the best software-engineering model to date. OpenAI also part-funded FrontierMath, where Astra posts 97.6%. The honest summary is that Astra is the strongest general computer-use model available and is not uniformly the strongest coder, which is exactly the shape a routing strategy is designed for.

Sources

• OpenAI API — GPT-6 Astra model reference (pricing, context, limits)
• OpenAI API — Pricing
• OpenAI API — Changelog, 3 September 2026
• Microsoft Azure — GPT-6 Astra now available in Microsoft Foundry
• VentureBeat — 'Welcome to the AGI era': OpenAI launches GPT-6 Astra
• Fortune — OpenAI launches GPT-6 Astra and touts its ability to use your computer
• Vellum — GPT-6 Astra benchmarks explained
• The New Stack — OpenAI launches GPT-6 Astra and says welcome to the 'AGI era'

Related tool reviews

• Read the ChatGPT review →
• Read the OpenAI Codex review →
• Read the OpenAI Operator review →
• Read the Claude review →
• Read the Gemini review →

Questions or corrections? Email Pick Right. Want the full list? See all news.