GPT-6 Astra Costs 2.5x More Per Token. I Went Looking for the 2.5x.

OpenAI shipped GPT-6 Astra on September 3 and described it as the world's most intelligent and aligned model. The top-voted reply on the Hacker News launch thread read, in full: "Title: 'major gains' First chart: from score 61 (GPT-5.6 Sol) to drumroll 61 (GPT-6 Astra)."

Another commenter summarized the whole release as "more like 5.7 not 6." The thread hit 1,003 points, and the most upvoted sentiment in it was that a mundane launch had arrived without even a livestream.

Both readings are defensible from the published numbers, which is the part worth writing about. The model got meaningfully better at some specific things, got worse at others, and got 2.5x more expensive per token on the same day. Almost every post covering it picked one of those three facts and built a conclusion on it.

I went looking for what the price increase actually buys a solo developer. The answer turned out to depend entirely on whether you measure per token or per task, and those two numbers point in opposite directions.

What is GPT-6 Astra?

It's OpenAI's successor to GPT-5.6 Sol, released September 3, 2026 as a limited preview and rolled out over the following days to Plus, Pro, Business, and Enterprise, plus the API as gpt-6-astra, Azure, and AWS Bedrock.

The concrete specs: a 1.05M token context window with 128K maximum output. Pricing at $10 per million input tokens and $50 per million output tokens, with cached reads at $1 and a 25% premium on cache writes. Batch and Flex tiers run at half the standard rate.

OpenAI's VP of research Aidan Clark said the training run was by far their largest, and the first time they pretrained on more than 100,000 GPUs at the Stargate site in Texas.

The architectural change that matters most is a technique OpenAI calls recurrent depth, which does more reasoning inside the model rather than emitting it as readable tokens. That's the source of both the efficiency gains and the loudest criticism, and I'll come back to it because it's the part with real consequences for anyone building on top of this.

How much does GPT-6 Astra cost compared to GPT-5.6 Sol?

Exactly 2.5x, on both sides of the meter. Sol was $4 in and $20 out. Astra is $10 in and $50 out.

For context on where that sits: Anthropic's Fable 5.1 is also $10 and $50. Gemini 3.8 Flash is $0.75 and $3.75. Meta's Muse is $1.25 and $4.25.

So Astra didn't price itself into a new tier. It priced itself into the existing frontier tier, from a promotional rate that was undercutting it. If you were on Sol specifically because it was the cheap frontier option, that option is gone.

That's the number every headline ran with, and taken alone it's misleading in a way that's worth being precise about.

Is GPT-6 Astra worth it? Run the cost per task, not the cost per token

Here's the arithmetic that changes the answer.

Astra is roughly 70% more token efficient than Sol on coding tasks. Artificial Analysis measured it using about one third the tokens of GPT-5.6 Sol at max effort inside Codex, and about one fifth the tokens of Claude Opus 5 at extra-high effort.

Multiply that against the 2.5x price and the coding math nearly cancels out. Artificial Analysis found that at max effort, Astra costs approximately the same per task as its predecessor while scoring two points higher on their Coding Agent Index.

Now run the same multiplication for everything else. On general intelligence tasks, the token savings are only about 10%, so the 2.5x price increase mostly survives. Their figure: 75% more expensive per task than Sol at max effort.

That's the actual shape of this release, and I haven't seen it stated plainly anywhere. If you're running agentic coding, the price went up and your bill probably didn't. If you're doing anything else, the price went up and so did your bill, by most of 2.5x.

Which means "is GPT-6 Astra worth it" isn't one question. It's two questions with different answers, and the marketing collapses them into one on purpose.

I want to flag a measurement problem before anyone builds a budget on those numbers. Cost per task is not a standardized unit. One vendor writeup put Astra at around $167 per task on aggregate coding benchmarks. A developer running his own code review measured $0.48 at low effort and $2.06 at max. Those differ by two orders of magnitude because they're measuring completely different things and both call it a task. Treat any per-task figure, including the ones I just quoted, as directionally useful and absolutely not as a line item.

Are the GPT-6 Astra benchmarks cherry-picked?

Some of them, yes, in the specific and legal way that launch charts always are.

Start with what's real, because there's a lot of it. On Terminal-Bench 4.0, Astra hits 57.7% against Sol's 37.3%. On OSWorld 2.0, a computer-use benchmark, 72.6% against 65.7%, and it completes tasks in roughly 40 minutes instead of 75, a 47% reduction in wall-clock time. On ScreenSpot-Pro, 92.7% against 76.9%. On AutomationBench, the widest gap of the set, 41.4% against Fable 5.1's 31.4% and Sol's 18.1%.

Long context improved substantially too. On the MRCR v2 eight-needle test in the 512K to 1M range, Astra scores 96.3% against Sol's 73.8%. If you've been avoiding stuffing a large codebase into a context window because retrieval fell apart past a few hundred thousand tokens, that's a real change.

It also saturates several evals outright: 97.6% on FrontierMath Tier 4, 99.9% on ARC-AGI-3 under OpenAI's own provider adapter harness, 100% on ExploitBench.

Now the selection effects.

OpenAI's launch materials quote DeepSWE rather than SWE-bench Verified, which means there's no like-for-like SWE-bench Verified comparison against GPT-5.6 at launch. On DeepSWE v1.1 itself, Astra's 74.1% sits within a point of Opus 5's 73.7%, and Meta reported 75.4% for Muse Spark 1.3 on the same test. The New Stack noticed that OpenAI's chart uses a 67.4% figure for Fable 5.1, which makes the lead look larger than other reported results support.

On FrontierCode Extended, Fable 5 scores 64.9% against Astra's 64.5%, so Astra loses that one.

And the row that isn't in the prose at all: Humanity's Last Exam, where Astra's 57.2% trails its own predecessor's 65.0%. A regression against the model it replaces, on a well-known benchmark, omitted from the narrative.

None of that is fabrication. It's ordinary chart curation, and the reason to point at it is that the independent aggregates tell a different story than the launch post does.

GPT-6 Astra vs Fable 5.1: what the independent numbers say

On Artificial Analysis's Intelligence Index v4.1.1, Astra scores 61.2 against Fable 5.1's 65.7. Against its own predecessor it's a tie at 61.

On their Coding Agent Index, Astra scores 67 running in the Codex harness. Opus 5 in Claude Code is about 67. Fable 5 is about 67. Muse Spark 1.3 in Muse Code is about 67. Fable 5.1 in Claude Code leads at 70.

That's a four-way tie for second place, and the model that launched with the word "generational" attached is in it.

I want to be careful about what this does and doesn't prove. Harness matters enormously here. Each model is being run inside its own vendor's agent, so you're benchmarking model-plus-scaffolding, not the model alone. Anyone who's watched the same model behave differently in two CLIs knows how much that swings. Artificial Analysis is explicit about the pairing, which is the right call, and it still means these aren't clean isolated comparisons.

The honest summary is that the frontier is crowded and the gaps are small. That was already true before September 3 and it's still true. What changed is that the cheapest way to sit at that frontier got 2.5x more expensive.

Also worth noting from the same source: Astra shows regressions in a few places, including roughly 80 Elo points on GDPval-AA v2. Mixed progress is the accurate phrase, not leap.

Everyone reviewing this model sells something adjacent to it

I ran the searches you'd run. The first page for GPT-6 Astra pricing and benchmark queries is MindStudio, Vellum, DataCamp, eesel, emergent.sh, layer3labs, Yotta Labs, alphacorp, benchlm.

Every one of those is a company whose product involves routing you to models, evaluating models, or teaching you about models. A new frontier release is a traffic event for all of them, and the post goes up within 24 hours regardless of whether anyone there has used it for a week.

That isn't an accusation of dishonesty. Most of those posts are accurate. It's the same pattern I found when I went looking for who publishes Product Hunt statistics: nobody in the top ten results is neutral, including the ones arguing against the hype, and the incentive isn't to be wrong, it's to publish fast and confident about something they can't have tested properly yet.

The two most useful things I read were the Artificial Analysis writeup, which sells benchmarking and shows its methodology, and a solo developer's post that ran the same code review at four effort levels and published the dollar amounts. Neither of them was in the top three results.

I'm including myself in this. I've had access to Astra for a matter of days, I have not shipped a product with it, and this post is arithmetic on other people's measurements. That's what it's worth.

What's genuinely new: the Critical cybersecurity rating

This is the most significant thing about the release and it got a fraction of the coverage the benchmarks did.

Astra is the first model OpenAI has rated Critical for cybersecurity under its Preparedness Framework. Their definition of that threshold is autonomous discovery and exploitation of novel vulnerabilities in hardened, real-world systems, without a human guiding each step.

The 100% ExploitBench score isn't a marketing number. It's the reason the rollout was staged.

What that means practically: the public version refuses advanced offensive work, completing exploit-writing tasks in about 2.4% of attempts. Less-restricted access for vetted defenders runs through a program called Daybreak Blue, aimed at vulnerability validation, malware analysis, and detection engineering.

If you ship software, the relevant part isn't whether you get access. It's that the capability now exists behind an API and the gating is a policy decision rather than a technical limit. The economics of finding bugs in your dependencies changed this week for both sides. That's a bigger deal for a solo developer running a public-facing app than any coding benchmark on this page, and I don't have a tidy action item for it beyond patching faster than you did last month.

What's genuinely worse: you can't read the reasoning anymore

Recurrent depth is why Astra uses a third of the tokens. It's also why you can't see what it did.

There's no readable chain of thought in the output. Safety researchers have raised monitorability concerns directly, and there's a finding worth quoting precisely: in evaluations designed to elicit monitoring evasion, Astra's written reasoning is harder to monitor than Sol's.

Set the existential framing aside and think about it as a debugging problem, which is how it'll reach you. When an agent does something wrong across a twenty-step task, the readable reasoning trace is how you find the step where it went off. Removing it doesn't just make oversight harder in the abstract. It makes your Tuesday afternoon harder.

The alignment numbers moved the right way on other axes, and they're not small. On a honeypot test measuring whether a model exploits unintended shortcuts, Astra scored 0% against Sol's 48.2%. Unauthorized transaction rate came in at 6.8% against Sol's 38%. Artificial Analysis measured hallucination dropping from 92% to 51% at max effort on their eval while accuracy rose four points, and OpenAI's internal measure went from 12.2% to 4.2%. Those are different benchmarks measuring different things and neither is the other, so don't average them.

So the trade is real and it goes both ways: a model that behaves better and explains itself less. Reasonable people will price that differently. What I'd resist is the framing where the safety improvements make the opacity a non-issue, because they're not the same axis.

Which effort level should you actually use?

This is the practical decision, and it's the one with the most money in it.

One developer published a clean test, running the same code review at each level:

• Low: 60 seconds, $0.48, found 5 bugs
• Max: 446 seconds, $2.06, found 7 bugs, with better ranking of the findings

Across a broader set, his per-task costs came out around $0.63 at low, $1.16 at medium, $1.41 at high, and $2.57 at max. The interesting part is the shape of that curve. Going from low to medium buys 3 index points for $0.53. Going from extra-high to max buys 1 point for $0.72.

OpenAI's own guidance says to use high for complex debugging, and to use the top effort level only when your evals show a clear benefit. That last clause is doing a lot of work, and it's a polite way of saying most people are overpaying by default.

Default to low. Escalate deliberately, for security reviews and hard debugging, not as a habit. A 4x cost multiplier for a 7-minute wait and two extra findings is a fine trade on an audit and a terrible one on a Tuesday.

The 20-minute version

If you were about to read six more launch analyses, do this instead:

• Work out whether you're a coding workload or a general workload. Coding, your per-task cost is roughly flat and you should upgrade. General reasoning and chat, you're looking at most of a 2.5x bill increase for a model that ties its predecessor on the independent aggregate. Those are different decisions.
• Check what you're actually running. If you're on GPT-5.6 Sol at the promotional rate for cost reasons, that rate is the thing that changed, not the model quality. Gemini 3.8 Flash at $0.75 and $3.75 is an eighth the input price and worth testing on the tasks where you never needed a frontier model.
• Set your effort level explicitly, once. Low is the right default. Max costs 4x and buys a point or two.
• Turn on caching if you have a stable system prompt. Reads are 90% off. That's a larger lever than the model choice for anything with repeated context.
• Don't rewrite your stack this week. The gaps between the top four models are a few index points and the harness accounts for some of that. This is a tie at the frontier, not a changing of the guard.

That's the whole decision. It took considerably longer to establish than it takes to execute, which is a pattern I keep running into.

The model was never the bottleneck

Here's the thing I actually believe about this release, and it isn't about OpenAI.

Astra is meaningfully better at computer use. It finishes agentic tasks in 40 minutes instead of 75. It holds a million tokens of context and can still find the needle. Whatever you were building last month, you can build it faster now.

I've shipped seven products. Not one of them failed because the model was too slow, the context window was too small, or the coding benchmark was two points lower than it could have been. They struggled because nobody knew they existed.

A 47% reduction in agent wall-clock time is a real improvement to the part of the job that was already the easy part. It does nothing whatsoever to the part that's actually hard, and it arrives with the same seductive quality as buying a boilerplate to skip the uncomfortable beginning: a concrete upgrade with a clear finish line, standing in for ambiguous work that has none.

Reading launch analyses is the purest form of this. It feels like keeping up. It's a measurable task with a completion state, and you can do it for two hours and end the day with a shipping velocity of exactly zero.

I'd also note that the same arithmetic trap shows up here as in the AI search traffic numbers. A ratio quoted without its base. 2.5x the price sounds like a decision until you multiply it against 70% fewer tokens and find out it's roughly flat for the thing you're doing. The headline number and the number you pay are different numbers, and only one of them is on your invoice.

Upgrade if you're writing code with an agent, because it's free in practice. Stay put if you're not, because it isn't. Then close the tab, because the model got faster and you still have to go find the people.