GPT-6 Astra vs Claude Fable 5.1: Same Score, Same Price, 2.3x the Cost

Anthropic shipped Claude Fable 5.1 on 1 September. OpenAI shipped GPT-6 Astra on 3 September. Both landed on 53 on the Artificial Analysis Intelligence Index, joint top of the board. Both list at $10 per million input tokens and $50 per million output tokens. Not similar. Identical.

That coincidence is more useful than either launch. When two models tie on the headline score and tie on the sticker price, the comparison stops being about which one is smarter — the board says neither — and starts being about everything the board does not show. Cost per unit of finished work. Time before the first token appears. What happens at 400,000 input tokens. Those differences turn out to be large, and the arithmetic below shows its working wherever I derive anything.

The headline finding is cost per task, and it is not close

Artificial Analysis reports the dollar cost of running its full evaluation suite through each model, which normalises for the thing per-token pricing hides: how many tokens a model spends to finish a job.

At the top of each vendor's effort ladder, GPT-6 Astra (max) costs $3.26 per index task. Claude Fable 5.1 (max with fallback) costs $7.63. Same score of 53. Same $10/$50 rate card. Astra does it for 43% of the money.

The mechanism is not mysterious. Artificial Analysis describes Fable 5.1 as verbose, and quantifies it: 190 million output tokens across the index against a 90 million median. Fable emits more than twice the tokens a typical model does to work through the same problems, and every one of those tokens is billed at $50 per million. The full evaluation run cost $13,128.86.

Astra pushes in the opposite direction. OpenAI's own claim for its record 74% on DeepSWE v1.1 is not just the score — it is that Astra reached it with fewer steps and better token efficiency than previous frontier models. Same rate card, fewer tokens, fewer turns, lower bill.

Not confirmed: Artificial Analysis has not published an output-token total for Astra on the index, and OpenAI has not published a full evaluation cost. So the 2.3x ratio is properly grounded in the per-task figures, but the token-count comparison behind it is one-sided — we know Fable's number and we have OpenAI's characterisation of Astra's.

And a caution that matters more than the number. This is one benchmark's workload mix: reasoning-dense, open-ended, output-heavy tasks that reward long chains of thought. If your production traffic is short-output classification, structured extraction or routing, output tokens are a small fraction of your bill and verbosity barely registers. On that shape the two models converge toward their identical input price and the 2.3x collapses to something close to 1x. The index ratio tells you what happens on hard, long-form reasoning work. It does not tell you what happens on yours. Run your own traffic through the token cost calculator before you treat 2.3x as your number.

The latency gap is the one that will actually change your product

Fable 5.1's time to first token is 262.88 seconds against a 3.73-second median across the field. That is not a typo and it is not network overhead. It is thinking time — the model reasons before it emits anything at all.

Four and a half minutes of silence is not a performance footnote. It is a constraint on what you are permitted to build.

What it rules out: anything with a human waiting. Chat interfaces, inline code completion, support widgets, voice, search-as-you-type. No amount of skeleton UI survives 262 seconds, and nothing about a blank chat window communicates "this will take four minutes".

What it does not rule out: batch pipelines, overnight document processing, nightly code review, research agents kicked off from a queue — anything with a job ID and an email at the end. In that architecture 262 seconds is free.

So Fable 5.1 pushes you toward asynchronous product shapes: submit, acknowledge, notify. That is a design decision, not a configuration flag. If your product is currently synchronous, adopting Fable at max effort means rebuilding the interaction model, and the cost of that rebuild belongs in the comparison alongside the token prices.

Once tokens start flowing, the ranking flips. Fable runs at 67.7 tokens per second; Astra at roughly 53. On a 4,000-token answer that is about 59 seconds against 75 — Fable is meaningfully faster to finish generating. It just takes an age to start.

Not confirmed: Artificial Analysis has not published a time-to-first-token figure for GPT-6 Astra. I am not going to assume it sits at the median just because Fable's is an outlier. Measure it yourself before you build a latency budget around it.

Side by side

Two rows deserve a second look.

Cached input. Astra reads cache at $1.00 per million, a 90% discount, but charges $12.50 per million to write it — you pay a 25% premium over the standard input rate to put something in the cache before you get the discount back on reads. Fable discounts cache hits by 98%, which on a $10 base works out at $0.20 per million. On a 100,000-token fixed prefix, that is $0.10 per request on Astra against $0.02 on Fable. If you are running a retrieval-augmented system with a large stable preamble and thousands of requests an hour against it, that 5x difference on the dominant term can outweigh the per-task gap entirely. Fable's cache discount is the strongest single argument for it in this comparison.

Provider count. Fable is reachable through five API providers; Astra through OpenAI directly and through AWS. For most teams this is noise. For anyone with a supplier-concentration clause or a formal second-source requirement in their procurement policy, it is a scoring criterion.

Context shape, and the cliff in Astra's pricing

The window numbers look like a tie — 1,050,000 against 1,000,000, a 5% difference nobody will notice. They are not, because Astra's window has structure and Fable's does not.

Astra splits its 1,050,000 into a 922,000-token maximum input and a 128,000-token maximum output. No single Astra response exceeds 128,000 tokens, however you configure it. Anthropic has not published a maximum output for Fable 5.1, so a workload needing one enormous unbroken generation is a case where you test rather than read the spec sheet.

Then there is the cliff. Any Astra request over 272,000 input tokens is billed at 2x the input and cache rates and 1.5x the output rate — applied to the whole request, not to the excess. No tapering. One token over the line and the entire call reprices.

Work it through on a large-context job: 400,000 input tokens, 20,000 output.

Astra, if the cliff did not exist: 0.4 × $10 = $4.00 input, plus 0.02 × $50 = $1.00 output. $5.00.

Astra, as actually billed: input runs at $20, so 0.4 × $20 = $8.00. Output runs at $75, so 0.02 × $75 = $1.50. $9.50.

Fable 5.1, same request: 0.4 × $10 = $4.00, plus 0.02 × $50 = $1.00. $5.00.

So on that shape Astra costs 1.9x what Fable does per call, before any consideration of how many tokens each spends. Set that against the 2.3x cost-per-task advantage Astra holds on the index and most of the advantage is gone. On genuinely large-context work the two are close to a wash, and which one wins depends on whether Fable's output verbosity costs more than Astra's input multiplier.

The irony is worth stating plainly: Astra's 922,000-token input capacity invites exactly the workload its own pricing penalises. A 272,000-token threshold is generous by historical standards and small relative to the window being advertised. If you will run above it, model the doubled rate from the start rather than discovering it in an invoice.

Not confirmed: Anthropic has published no equivalent threshold for Fable 5.1. That is not the same as confirming there is none — it means none is documented. Watch your first large-context bill.

The effort ladder is where the decision actually gets made

Almost every comparison of these two models argues about the top rung, and almost no production system should be running there.

At medium effort, Astra scores 50 for $1.54 per task. Fable scores 49 for $2.98. Astra is one point ahead and costs 52% as much — a 1.9x gap.

At high, the scores tie at 51. Astra costs $1.72, Fable $3.91. That is 2.27x for an identical score, which is the cleanest single comparison in this entire piece: same model class, same benchmark, same number on the board, one costs more than twice as much.

Note what else that table says. Astra at low scores 46 for $0.82, which beats GPT-5.6 Sol at max on the same board. Astra's lower rungs are not degraded fallbacks; they are competitive models in their own right at a quarter of the price of the top one.

The general lesson is older than either release and teams keep relearning it: the marginal intelligence between medium and max is small, and the marginal cost is not. Astra goes from 50 to 53 — three index points — while its cost per task more than doubles, $1.54 to $3.26. Fable goes from 49 to 53 for $2.98 to $7.63, a 2.6x increase. Unless you have measured that those last few points change an outcome your business cares about, you are paying a large premium for a rounding error, and paying it on every request.

Where each one genuinely wins

GPT-6 Astra wins on engineering and agentic work. The 74% on DeepSWE v1.1 was a record at the time, and OpenAI positioned the model as "a new frontier on computer and browser use" and "the best model for software engineering to date". The token-efficiency claim compounds it — for long-horizon agent runs where a task involves dozens of tool calls, fewer steps per task multiplies through the whole trajectory. A 20% reduction in steps on a 50-step agent run is not a 20% saving on one call; it is 20% off everything downstream of it too.

Unquantified vendor claim, flagged as such: Astra was reported to beat OpenAI's own Sol and Anthropic's Fable on bug-finding, terminal work and codebase queries. No scores were published for any of those three. I am reporting the claim because it exists and because it is directionally consistent with the DeepSWE number, not because it is evidence. Treat it as marketing until someone publishes a table.

Claude Fable 5.1 wins on prompt reuse and on posture. Joint top of the board is not a consolation prize — it is the same 53. Its 98% cache discount is the best on offer here and it rewards exactly the architecture most production systems already have: a large stable system prompt, a fixed tool schema, a long retrieved context, a small variable suffix. If your prefix dominates your token count, Fable's economics look nothing like what the index cost-per-task suggests, because the index does not reward prompt reuse the way your application does.

Anthropic's alignment posture is the other reason teams choose it, and it is a legitimate procurement input even though no leaderboard scores it. OpenAI contests the ground directly: Greg Brockman called Astra OpenAI's "most intelligent and, also very importantly, our most aligned model yet", and OpenAI states that Astra produces fewer misaligned outcomes than any frontier model it has tested. Both are vendor statements about their own models, and neither is independently verified here.

I am not going to manufacture an overall winner. On the published evidence, Astra is cheaper per unit of result on reasoning-heavy work and better at software engineering; Fable is cheaper on heavily cached workloads, faster once it starts generating, and identical on raw capability. Which of those decides it is a fact about your workload, not about the models.

What neither vendor is putting in the press release

Astra's reasoning is harder to audit. OpenAI chief scientist Jakub Pachocki said that "as model capabilities are increasing, monitorability is getting more challenging", tied to the model's use of opaque recurrence. The practical effect is that chain-of-thought auditing is harder on Astra than on models that reason in plain text. If your compliance regime involves inspecting reasoning traces — regulated finance, clinical decision support, anything with a model-risk-management function attached — this is a procurement fact and it belongs in the risk register, not the footnotes.

Astra sits at OpenAI's internal "Critical" cybersecurity threshold, the first OpenAI model to do so. It scored 100% on ExploitBench, and in a modified version of that test found and exploited two zero-day vulnerabilities. OpenAI said it would limit access to those capabilities, and rolled out first through its application-based cyber programme, Daybreak, before ChatGPT tiers, the API and AWS. If your use case is anywhere near security tooling, expect gating and build the approval lead time into your plan.

Anthropic publishes no parameter count for Fable 5.1. Closed weights, undisclosed size. That is normal for the tier and it is also a limit on what you can independently model about serving cost, quantisation behaviour or the practical ceiling on throughput.

Availability is asymmetric. Five API providers for Fable against OpenAI plus AWS for Astra. And OpenAI put Pro subscriptions on hold on 10 September because of Astra demand — a capacity signal rather than a product one, but a real input if you are planning a launch that depends on headroom.

For the full specification breakdown on the OpenAI side, we went through the rate card, the endpoints and the tool surface in the GPT-6 Astra deep dive.

The recommendation, by workload

Agentic coding and long-horizon tool use: Astra. The DeepSWE record, the step-efficiency claim, the computer-use positioning and the cost-per-task advantage all point the same direction, and the compounding effect of fewer steps is largest exactly here. Run it at high rather than max — the scores tie at 51 and you save half the money.

Long-context document work: Fable 5.1, unless you can stay under 272K. Astra's cliff repriced our 400,000-token example at 1.9x Fable's cost, which erases the efficiency advantage on the one workload its 922,000-token input window most obviously invites. If you can chunk below 272,000 input tokens per request, that reverses and Astra wins again. Chunking is usually cheaper than the cliff. Test both.

High-reuse, prompt-cached workloads: Fable 5.1. A 98% discount against Astra's 90%, with no cache-write premium, is a 5x difference on cache reads. When the fixed prefix dominates the bill, that term decides the comparison and the index cost-per-task figure is close to irrelevant.

Interactive products: neither, at top effort. A 262-second time to first token disqualifies Fable at max for anything synchronous, and Astra's TTFT is unpublished so you cannot plan around it without measuring. Either run these models at lower effort and benchmark the real latency on your own traffic, or put a fast, cheap model in front of them and escalate only the requests that need it. Most interactive traffic does not need a 53.

Cost-sensitive volume: neither. At $10/$50 both are frontier-priced, and a large share of production traffic is classification, extraction and routing that a model at a twentieth the price handles identically. The open-weight tier has moved a long way this year — DeepSeek V4.1-Flash and GLM-5.3 are the current reference points — and the saving comes from placement rather than adoption. Route the hard slice to a 53 and everything else somewhere cheaper.

The clean part of this comparison is that the sticker price cancels out. Two models, same rate card, same score, and the decision still turns entirely on cost per task, latency shape, cache economics and a pricing cliff at 272K. That is the general case, not an artefact of these two releases. Sticker price and leaderboard position are the two inputs that are easiest to find and the two that tell you least.

---

Related: the live model leaderboard for current index positions, and the token cost calculator to run these rates against your own traffic shape.