Stop Pricing the Token. Price the Job.
"GPT-6 Astra costs 2.5x the last flagship. OpenAI's defense? 'It finishes tasks in fewer tokens.' That single line kills the way everyone shops for AI. Stop comparing the sticker price per token. Start measuring the price per finished job — because that's the only number that was ever real.
GPT-6 Astra went fully public today — and everyone's arguing about whether it's AGI. That debate is spent, and frankly it was never the useful one. The useful story is hiding in a pricing footnote, and Ben Rogojan's essay on your list — "Engineers Are Obsessed With the How and Often Forget Why" — is the exact lens to read it through. Because Astra's launch just quietly broke the way the entire industry shops for AI, and getting this right is worth more to your budget than any opinion about artificial general intelligence.
Here are the numbers. Astra costs $10 per million input tokens and $50 per million output — 2.5x the price of the previous flagship, GPT-5.6 Sol ($4/$20). That's a steep, scary sticker, and the instinct — the how-brained instinct Rogojan is warning about — is to recoil: "2.5x more expensive, I'll stick with the cheaper model." But read OpenAI's own defense, because it's the whole point: a higher per-token price does not automatically mean a higher bill. OpenAI argues Astra finishes many tasks in fewer tokens and fewer retries, which can offset the rate on a per-task basis. Sit with that, because it's the most important shift in how to think about AI cost in 2026: the price you pay is not the price per token. It's the price per finished job — and those are wildly different numbers.
This is Rogojan's "why vs. how" made concrete, and it's the trap almost every team is falling into right now. The how-obsessed engineer compares models on a spec sheet: which has the lower per-token rate, the bigger context window, the higher benchmark. Clean, measurable, and often completely misleading. The why-focused engineer asks the only question that matters: what does it actually cost to get my specific job done, correctly, end to end? A cheap model that needs five attempts, three clarifying round-trips, and a human to fix its mistakes can easily cost more — in tokens and in your time — than an expensive model that does it right in one pass. The per-token price is the how. The per-task cost, including retries, failures, and human cleanup, is the why. Astra's pricing forces the question into the open: is it 2.5x more expensive, or does it do in one clean pass what Sol needs five messy tries for? You cannot answer that from the price sheet. You can only answer it by measuring the finished job. And the teams that keep shopping on sticker price per token — the ones stuck on the how — are going to make systematically wrong decisions, either overpaying for a cheap model that fails a lot or dismissing an expensive one that's actually cheaper per outcome.
There's a real engineering discipline hiding in here, and it's genuinely actionable — the kind of thing that separates a data team that controls its AI spend from one that just watches the invoice climb. Define your unit of work, then measure cost per unit — not cost per token. For a coding task: cost to a merged, working PR, including every retry and review cycle. For a support agent: cost per resolved ticket, not per message. For a data pipeline: cost per correct output, not per call. Once you measure that way, the whole model-selection question transforms. Sometimes the expensive model wins because it one-shots the task. Sometimes the cheap model wins because your task is simple and forgiving. But you'll know, instead of guessing from a rate card. This is also exactly why model routing (the thread this run has hammered) is so valuable — route the simple, forgiving jobs to the cheap model and the hard, retry-prone ones to Astra, because the right choice is per-task, not per-account. Astra didn't just launch a model. It made "measure the job, not the token" unavoidable.
And the deeper Rogojan point lands on more than pricing — it's the lens for this whole AGI-hype weekend. Everyone's obsessed with the how: is it AGI, what's the benchmark, what's the parameter count. Almost no one's asking the why: what problem does this actually solve better for me, and is that worth it? OpenAI itself leaned into the why framing that matters — Altman said Astra "changed his workflows," and the headline capability is computer use: navigating spreadsheets, filling forms, moving across web pages at what Brockman called superhuman speed. That's a why pitch — not "it's smarter," but "it does your tedious work." Whether that's worth 2.5x is, again, a per-task question you have to measure, not a benchmark you can read. The engineers who win this era aren't the ones who know the most about how the models work. They're the ones who never lose sight of why they're using one.
The rest of the day, briefly. Astra's full public rollout is real but phased and messy — restricted version for the public (cyber capabilities stripped), off-by-default in Enterprise/Edu (owners must manually enable), regional limits on Fast mode in the EU, and a genuinely useful honest footnote from the trackers: Astra's DeepSWE coding score (74.1%) is a real gain over Sol, but Meta's Muse Spark 1.3 reportedly edged it at max settings — so "best coding model" is contested, not settled. Frame Astra as "a real jump, top-tier, not uncontested." Verify your access rather than assuming it's live; this is a rolling window, not a switch.
The builder's bench fits the "why not how" theme nicely. ClickHouse as a streaming HTTP API is a genuinely clever capability — turning your analytics database into a live data endpoint, which collapses a whole layer of infrastructure (why build a separate API service if the database can stream directly?). Snowflake Ventures announced it's investing in enterprise AI infrastructure — the warehouse players putting capital into the layer around the model, exactly where value keeps migrating. xAI set Grok Bot loose on procurement — agents moving into yet another unglamorous-but-huge enterprise workflow. And Simon Willison had two: "Introducing GPT-6 Astra for developers" (the practitioner's read on what actually changed for building — start here if you're evaluating Astra) and a delightful "Using Blender with coding agents on macOS" (agents driving 3D software — the "computer use" thesis in the wild, and a fun weekend experiment).
The through-line, one sentence: on September 5 GPT-6 Astra launched publicly at 2.5x the last flagship's price, and OpenAI's own defense — "it finishes tasks in fewer tokens" — turned Ben Rogojan's "why vs. how" essay into the practical lesson of the day: stop comparing models on price per token (the how) and start measuring price per finished job (the why), because that's the only number that was ever real, and it's the one almost everyone is getting wrong.
One thing to do today: change one number in how you evaluate AI. Pick your most important AI workflow and stop measuring its cost in tokens or per-call price. Instead, define the unit of finished work — a merged PR, a resolved ticket, a correct report — and measure the full cost to produce one, including every retry, failed attempt, and minute of human cleanup. Then, and only then, compare models on that number. You'll almost certainly find that some of your "cheap" model usage is quietly expensive (all those retries and fixes), and that Astra or another premium model is cheaper than it looks on the sticker for your hardest tasks. That's the shift from how to why Rogojan is pointing at, and Astra's pricing just made it urgent. The engineers who measure the job instead of the token will run the AI budgets that make sense. Everyone else is optimizing a number that was never the real cost.
Sources covered
1 story · 5 sources (0 news, 2 company, 3 voices)