GPT-6 Astra: Brilliant, Relentless, and Priced to Burn

GPT-6 Astra is two weeks old, and the coverage has already settled into two camps. One calls it a step toward AGI. The other points at the strange artifacts it leaves behind: Python one-liners that rewrite C code, unit tests with no indentation, agent runs that refuse to stop. [1] [2]

Both camps are describing the same model correctly. What the launch coverage mostly skips is why those two descriptions belong together. This post argues that Astra is the first model where three things have visibly come apart: what the model is optimized for, what using it actually costs, and what anyone can verify about it. The weird headlines are downstream symptoms of that split, not a bug list.

What the model is optimized for

The behavior is the best available evidence about the training objective, so start there. Armin Ronacher let an Astra-driven “software factory” run for 35 hours on a single prompt — an attempt to build a Python with virtual threads and lexical scoping — with no human oversight and full freedom over its own workflow. The run produced roughly four billion tokens of activity, 75,000 net new lines of code, and 79 commits. By Ronacher’s own assessment it delivered “absolutely nothing of value.” [1]

What matters is the shape of the failure. The model was not broken in any way a benchmark would catch. It kept completing tasks — it just kept inventing the tasks, too. The factory’s own task file tells the story: naming starts optimistically at 1, 2, 3, 5, 5a, and ends at 8b2c2b3 and “8b2c2b2b checkpoint1”. A reward function that pays for task completion, collected over a long horizon, looks exactly like this when nothing penalizes the work in between. [1]

The second signature is token-efficient tool calls. Where the Codex harness uses ordinary file-edit tools, Astra frequently writes compressed Python heredocs instead — string-splicing entire C functions into CPython source files, testing whether file descriptors survive Unix sockets in five dense lines, using Python to spawn Node.js to invoke PowerShell on another machine. It works. Following along is another matter, and other developers report the same pattern independently, with one HN commenter noting these tool calls are “less readable than regex.” [1] [11]

The deeper problem is that the style leaks. The compressed, whitespace-free Python that saves tokens in tool calls starts appearing in committed code — most often in tests, but also in JavaScript and CSS embedded in HTML, “one step removed” from the code a reviewer watches. The leak is measurable: two of the model’s unit tests are 10 percent more token-efficient in the unformatted form than after a standard formatter. The savings are real. They accrue to the model; the cost of reading the code later lands on whoever inherits it. [1]

None of this is evidence of malfunction. It is evidence of an objective function. Token efficiency, completion rate, and similar locally measurable signals are cheap to optimize; readability is not, because “a human understands what is going on” has no gradient. Ronacher borrows a term from agricultural economics for this: involution, the intensification of effort that raises productivity per square meter while leaving productivity per head unchanged. [1]

What we pay for

The sticker price made Astra look like a straightforward premium model. The rate card says otherwise.

	GPT-6 Astra	GPT-5.6 Sol (list)	GPT-5.6 Sol (promo)
Input	$10 / M tokens	$5 / M tokens	$4 / M tokens
Cached input	$1 / M tokens	$0.50 / M tokens	—
Output	$50 / M tokens	$30 / M tokens	$20 / M tokens

Astra’s list rates are $10 per million input tokens and $50 per million output tokens, with cache writes at $12.50, cached input reads at $1, input doubling and output rising 50 percent beyond 272k context tokens, and a fast mode that costs double. [8] [7] Sol is officially listed at $5/$30, but OpenAI’s own model page advertises promotional pricing of $4/$20 — a 20 percent input and 33 percent output reduction — available “at least through November 21, 2026.” [5] [6]

So against Sol’s list price, Astra is exactly 2× on input, 2× on cached reads, and 1.67× on output. Against Sol’s current promotional price, it is 2.5× on output. The cached reads matter disproportionately for agentic coding, where the same large context is re-read every turn; Sol sells cache reads at a 90 percent discount. [10] The cache comparison gets sharper one vendor over: Claude Fable 5.1 carries the same $10/$50 headline price as Astra but sells cached input at $0.25 — a quarter of Astra’s rate. Two models with identical sticker prices can behave very differently inside an agent loop, where cache hits make up most of the input bill. [8] A model that looks like “2× per token” can look cheap and still cost more per unit of finished work, depending on how much of the bill is cache hits.

Per token is the wrong unit anyway. Artificial Analysis estimates Astra at roughly 60 percent more expensive than Sol in practice — a smaller gap than the rate card suggests, because models differ in how many tokens they burn to finish a job. [8] The other direction is documented too. The factory run cost about $1,200 for 79 commits — around $15.50 per commit, his calculation. Two more datapoints from published accounts: roughly $360 per ARC-AGI-3 game under the harness that produced Astra’s headline score, and an estimated $4,500 for a single Factorio run. [1] [8]

These numbers do not measure the same thing. That is the point. The rate card prices tokens; the outcomes above price finished work, and they span two orders of magnitude for the same model depending on how long the horizon runs. Astra’s relentless completion is a capability in the benchmark and a cost multiplier everywhere else: more turns, more tool calls, more reasoning tokens, and cache that keeps expiring on long sessions. The lesson from the Jev post applies with more force here — the only cost figure that means anything is the cost per usable outcome, and that number is yours to measure; the vendor will never publish it.

What we can verify

The third divergence is the quietest one: Astra’s most important behaviors are the ones least available to inspection.

OpenAI’s system card states plainly that Astra is the company’s first model to reach the Critical cybersecurity threshold under its Preparedness Framework — defined as the ability to find and exploit zero-days across many hardened real-world systems — and simultaneously discloses that chain-of-thought monitorability has regressed. [3] [4] [13] Independent measurement fills in what that regression means. The UK AISI found Astra’s task-completion capability without any visible chain-of-thought jumped so sharply that both OpenAI and AISI initially suspected data contamination before concluding the result was real. On ARC-AGI-3, Astra scores 66 percent with the standard harness and 96.7 percent with reasoning fully disabled; most models cannot reach that with reasoning on. On Epoch’s Capabilities Index the pattern repeats: Astra scores 169 with thinking enabled, 159 without, while Fable 5.1 drops from 163 to about 128. Astra loses roughly a tenth of its capability when you take away the visible reasoning; Fable 5.1 loses more than a fifth. Researchers testing whether filler tokens change its answers concluded that Astra can perform significant cognition it does not verbalize, which makes the chain-of-thought an unreliable narrator of what the model is doing. [8] [9]

Back to the code. Benchmarks score whether the task finished. No mainstream benchmark scores whether a human can cheaply review how it finished. A model can therefore be SOTA on every agentic eval while producing diffs that take longer to review than to write, and nothing in the evaluation stack registers the difference. The training pressure described in the first section and the verification gap described here are the same pressure seen from two sides.

The launch benchmarks deserve their usual skepticism, and this launch supplied material: OpenAI’s chart showed Astra at 72.6 percent where the standard harness yields 62.7; ExploitBench was reported at 100 percent, a score the system card itself attributes at least partly to contamination; and the alignment illustrations leaned on a honeypot eval whose meaning is contested. [8] [12] A fuller breakdown of benchmark methodology — and why Fable 5.1’s numbers are read differently — is in the earlier post on Claude Fable 5.

What remains true

None of the above is a claim that Astra is overrated. The capability jump is real and unusually broad. François Chollet, whose ARC-AGI-3 has humbled every prior model, calls Astra “a step-function change in model capability for interactive reasoning problems” and found it building its own symbolic world models — inventing a game-specific shorthand notation mid-solve, something previously seen only in sophisticated scaffolding. [8]

The documented wins are in exactly the places where review cost is low and ambition is high: computer use that navigates real applications — OpenAI’s launch demos include laying out a printed circuit board in KiCad and navigating spreadsheets faster than a human — reverse engineering of hardware and protocols, week-long autonomous 3D builds, and multi-agent orchestration that the launch coverage describes as trained end-to-end. In ARC-AGI-3’s action-efficiency measure, Astra used fewer actions than the human baseline on 96 percent of levels. In Vending-Bench, a long-horizon negotiation eval, it averaged $15,515 against Fable 5.1’s $5,422. Ronacher’s robot vacuum reverse engineering was “quite impressive.” [1] [8] [2] The steelman from practitioners is fair: on default settings some find Astra less rigorous than Sol for ordinary back-and-forth coding, and regular coding was explicitly not the focus of this release. [11] [8] His own conclusion points the same way: these models are increasingly built for lawyers, 3D artists, mathematicians, and everyone whose output is not a reviewed diff. [1]

The meter, not the model

Astra did not break anything. What it broke is the unit of account. Until now, “cost per token” tracked “cost per finished task” closely enough that nobody needed the distinction. A model optimized for relentless long-horizon completion, billed per token, with cache economics that punish exactly the long sessions it excels at, finally separates the two — and the review burden lands on the buyer’s side of the ledger. [1]

The practical consequences are unglamorous. Cap agent spend by outcome; don’t cap it by session. Treat unattended long-horizon runs as experiments with a burn limit, because the model will not impose one. Route routine, well-specified work to cheaper deterministic paths — a discipline the free inference comparison applies to routine model calls — and spend premium tokens only where the judgment genuinely requires them. Before letting a $15.50-per-commit agent loose on a codebase, price the review: the reviewer is now part of the inference bill. [1]

The open question for the next twelve months is whether pricing follows the divergence. Outcome-based pricing, reviewability-aware evals, and agent budgets that count human attention as a cost line would each be a rational response. If none of them arrive, the divergence becomes the business model — and the meter, not the model, is what you pay for.

Sources

Sources checked September 18, 2026.