GPT-6 Astra vs Claude Fable 5.1: Who Wins?

OpenAI shipped GPT-6 Astra on 3 September 2026, two days after Anthropic shipped Claude Fable 5.1. They land on the same list price — $10 per million input tokens, $50 per million output — with near-identical context windows and the same 128K output ceiling. On paper they are the same product at the same price.

They are not. One of them doubles its input rate past a threshold you will cross without noticing, and the other charges four times as much to read its own cache. Here is who actually wins, and where.

The short answer

GPT-6 Astra wins the capability contest. It leads on eleven of the fourteen published head-to-head benchmarks, sometimes by a wide margin, and independent measurement puts it at roughly a third of Fable 5.1's cost per completed task. If you want the single sentence: for most work, Astra is the stronger and cheaper model.

Claude Fable 5.1 wins two specific fights, and wins them structurally. Above 272,000 input tokens Astra's pricing steps up and Fable's does not, and Fable reads cached context at a quarter of Astra's rate. For long-context work and cache-heavy agent loops, Fable is between two and five times cheaper — a gap no benchmark difference closes.

So the honest answer to "who wins" is that Astra wins more often, but the cases where it loses are predictable from your workload shape rather than from any leaderboard.

At a glance

The benchmarks: Astra wins, and not narrowly

There is no way to read the published head-to-head numbers as anything other than a win for OpenAI.

Two patterns are worth pulling out of that wall of numbers.

Astra's biggest leads are in maths, science and machine operation. FrontierMath, Terminal-Bench Science, BenchCAD, AutomationBench and ScreenSpot-Pro are all double-digit gaps. If your work is quantitative research, engineering artefacts, or an agent driving a GUI, that is not a rounding error — it is a different class of result.

Fable 5.1's three wins are all on aggregate or tool-using measures. Humanity's Last Exam with tools, and both Artificial Analysis composite indices. These are the benchmarks that blend many tasks rather than testing one capability, which suggests Fable is more consistent across a broad spread while Astra is stronger at the peaks.

One caveat that cuts in Fable's favour on the coding index: the two models ran in different harnesses — Codex for Astra, Claude Code for Fable. Part of that three-point gap belongs to the scaffolding rather than the model, and it is not possible to say how much from outside.

The one genuinely eye-catching number is ExploitBench, where Astra scores 100% against Fable's 70%. Defensive security tooling is a real and growing use case, and a thirty-point gap there is decisive.

Pricing: identical on paper, not in practice

Both models list at $10 input and $50 output per million tokens, with the same $12.50 cache writes and the same 50% batch discount. Two differences sit underneath that:

• Cache reads. Fable 5.1 charges $0.25 per million. Astra charges $1.00 — four times as much.
• The 272K cliff. Once an Astra request exceeds 272,000 input tokens, the whole request reprices: $20 input, $2.00 cached reads, $75 output. Fable has no equivalent surcharge at any length.

Hold the token counts identical and compare what a single turn costs:

On a plain chat turn with no cached context the two are exactly the same price. Add any cached context at all and Fable pulls ahead on the cache rate. Cross 272K and the gap stops being a gap and becomes a cliff.

The cliff is steeper than it looks

Because the surcharge reprices the entire request rather than only the tokens above the line, a small increase in context can nearly double your bill:

cached 250,000  ->  Astra $0.3450   Fable $0.1575   (2.2x)
cached 272,000  ->  Astra $0.6965   Fable $0.1630   (4.3x)

A 9% increase in context doubles the Astra cost. If you are running anything that grows its context as it works — a long agent session, a document pipeline, a codebase-wide refactor — you will cross that line mid-run, and the invoice will not tell you which requests did it.

But cost per task tells the opposite story

Here is where a lazy analysis goes wrong. Everything above holds token counts constant, which isolates the pricing but ignores a real difference: the two models do not spend the same number of tokens on the same problem.

Artificial Analysis measured the cost of running its full Intelligence Index at maximum effort:

• GPT-6 Astra — $1.67 per task
• Claude Fable 5.1 — $3.76 per task

Astra is 2.25x cheaper to get the same work done, at identical list rates, because it thinks in fewer tokens. Fable's higher aggregate index score is partly bought with output volume, and output is the expensive meter at $50 per million.

So the two analyses answer different questions, and both are true:

• Per token of cached context, Fable is cheaper — by 4x, or 8x past the cliff.
• Per completed task on ordinary work, Astra is cheaper — by about 2.25x.

Which one governs your bill depends entirely on whether your cost is dominated by re-reading context or by generating reasoning. Agent loops that hold a large fixed context and emit short actions are the first shape. One-shot hard problems with a modest prompt are the second.

Speed and latency

Fable 5.1 is the faster of the two on both measures that matter: 67 output tokens per second against Astra's 54, and a lower time to first token. Neither is fast in absolute terms — these are maximum-effort reasoning models, and measured time to first token runs into the hundreds of seconds on hard problems. Plan for streaming, progress UI and generous timeouts on either.

If latency is genuinely your constraint, neither of these is the right tool. Both vendors sell cheaper, faster models for work that does not need this much thinking.

The practical differences when you actually switch

Swapping the model string is not sufficient in either direction. Fable 5.1 in particular has a stricter API surface than most people expect:

• Thinking is always on in Fable 5.1. Omit the parameter or send adaptive; explicitly disabling it, or passing a legacy token budget, returns a 400. Astra exposes five reasoning-effort settings, as does Fable.
• Forced tool use is rejected on Fable 5.1 — tool_choice of any or a named tool returns a 400. Use auto plus an instruction, strict schemas, or structured outputs.
• Fable can decline a request with a refusal stop reason returned as HTTP 200, not an exception. Code that reads the response content without checking the stop reason will silently process nothing. Enable server-side fallbacks.
• Editing conversation history breaks Fable's thinking blocks, returning a 400 for newer accounts. If your harness compacts or rewrites earlier turns, it needs to become append-only first.
• Fable requires 30-day data retention and is unavailable under zero data retention without express authorisation — which settles the choice outright for some regulated teams.
• Astra has no mini or nano tier at launch, so there is no cheap sibling to route easy traffic to within the same family. Its knowledge cutoff is 30 April 2026.

So who wins?

Choose GPT-6 Astra if

Your work is maths, quantitative research, or the physical sciences, where the FrontierMath and Terminal-Bench Science gaps are large. You are building computer-use or GUI automation, where ScreenSpot-Pro and AutomationBench favour it clearly. You are doing defensive security work, where the ExploitBench gap is thirty points. Or you simply want the lower bill on ordinary tasks with modest context — which is most products.

Choose Claude Fable 5.1 if

Your requests routinely exceed 272,000 input tokens, where Astra's surcharge makes it two to five times more expensive for the same work. Your agent loop is dominated by cached context reads, where the 4x cache-rate advantage compounds on every turn. You want the higher independent aggregate scores and are willing to pay in tokens for them. Or you want the faster of the two.

The verdict

On the evidence, GPT-6 Astra is the better model for most people: it wins the large majority of published benchmarks, it wins several of them decisively, and it costs less than half as much per completed task. That is a clear result and it would be dishonest to soften it.

What keeps this a genuine contest rather than a rout is that Fable 5.1's advantages are structural rather than marginal. A benchmark lead of two or three points can be closed by a model update next month. A 4x cache rate and the absence of a long-context surcharge are properties of the price sheet, and they produce five-fold cost differences on exactly the workload — long-running agents over large codebases — that a lot of serious engineering work now consists of.

Work out which of the two shapes your workload is before you read another benchmark table. If your context is small and your problems are hard, take Astra. If your context is enormous and your outputs are short, the leaderboard is answering a question you did not ask.

A note on these figures

Both models are days old at the time of writing, and benchmark indices in particular get re-scored as leaderboards re-run their suites — Artificial Analysis reports different index values under different effort and harness configurations, and the figures above are the maximum-effort ones. Vendor-published benchmarks are self-reported and were run in each vendor's own harness. Prices and behaviour reflect published rates as of 11 September 2026. The cost tables are arithmetic on list prices rather than measured invoices; treat them as the shape of the decision and verify against your own usage before committing budget.