Since GPT-6 Astra launched on 3 September, the question we have been asked more than any other is the narrow one: for writing and maintaining code, is it better than Claude Fable 5.1.
The marketing answer is yes. The independent answer is no. The useful answer needs about four hundred words of arithmetic, and it turns on something neither launch post leads with.
Both models list at 10 dollars per million input tokens and 50 dollars per million output tokens. Identical headline price. That looks like a tie and it is not, because a coding agent barely pays the headline rate. It pays the cache rate, over and over, and on that number the two are four times apart.
1. The benchmarks, both readings
Start with what OpenAI published, since it is the most complete side by side available.
| Benchmark | GPT-6 Astra | Fable 5.1 | Margin |
|---|---|---|---|
| Terminal-Bench 4.0 | 57.9% | 55.8% | +2.1 |
| DeepSWE v1.1 | 74.1% | 67.4% | +6.7 |
| FrontierCode 1.1 Extended | 64.5% | 63.6% | +0.9 |
| FrontierCode 1.1 Main | 53.3% | 50.9% | +2.4 |
| Internal database migration | 63.9% | 57.8% | +6.1 |
| Artificial Analysis Coding Agent Index | 67.0 | not listed | n/a |
Read straight, Astra wins every row. Read with the footnotes, three qualifications appear.
Most of those margins are small. Two points on Terminal-Bench and under a point on FrontierCode Extended are inside the range where harness details and run to run variance matter. On FrontierCode Main, Astra's 53.3 is actually behind Claude Fable 5 at 53.5 and Opus 5 at 53.4, which is to say the whole top of that benchmark is one cluster.
Astra was given a prompt advantage on FrontierCode. OpenAI's footnote 8 says it ran with a developer message resembling its Codex system prompt, adding that the prompt was not optimised for the evaluation. That is a fair disclosure, and it still means the models were not prompted identically.
And the last row is the interesting omission. OpenAI lists its own Artificial Analysis Coding Agent Index score of 67.0 and leaves the Fable 5.1 cell empty. Artificial Analysis filled it in: measured in Claude Code, Fable 5.1 leads that index at 70, with Astra at 67 in Codex, roughly level with Opus 5 and Fable 5.
That difference is not a gotcha, it is a different question. OpenAI's rows mostly measure the model. The Artificial Analysis index measures the model inside the harness you would actually use, which for coding is the whole point, because nobody runs a raw model against a repository.
2. The number the price list hides
Here is the part that changes the decision.
| GPT-6 Astra | Claude Fable 5.1 | |
|---|---|---|
| Input | $10.00 | $10.00 |
| Output | $50.00 | $50.00 |
| Cache read | $1.00 | $0.25 |
| Cache write | $12.50 | standard |
| Above 272K input tokens | 2x input and cache, 1.5x output | no multiplier |
Astra caches at the conventional tenth of the input rate. Anthropic priced Fable 5.1's cache reads at 0.025 times input, a multiplier no other model in their range gets, which VentureBeat reported as a 75 percent cut against Fable 5 and an estimated 25 percent saving on typical workloads, rising to around 45 percent on highly agentic ones.
Why that matters here specifically: a coding agent is the most cache heavy workload there is. Every turn resends the repository map, the open files and the conversation so far. After the first turn almost the entire input is a cache read, so the cache rate is the number that multiplies across a fifty turn session while the headline rate barely moves.
Run it on a normal session, 200,000 tokens of context resent each turn at a 90 percent cache hit rate, 2,000 tokens of output, fifty turns:
- GPT-6 Astra: 24.00 dollars
- Claude Fable 5.1: 17.25 dollars
Fable 5.1 is about 28 percent cheaper, on identical headline pricing.
Now push the context to 300,000 tokens, which a large monorepo does without trying. Astra crosses its 272,000 token threshold, and the multiplier applies to the whole request, not just the tokens above the line:
- GPT-6 Astra: 64.50 dollars
- Claude Fable 5.1: 23.38 dollars
Astra costs 2.8 times as much for the same session. That is not a rounding difference, it is a different budget.
3. The fair counterargument
Astra uses fewer tokens, and that is real. OpenAI reports roughly 65 percent fewer output tokens than Opus 5 on Agents' Last Exam. Artificial Analysis measured Astra as about 70 percent more token efficient than GPT-5.6 Sol on coding tasks, using around a third of the tokens at max effort.
So the cost comparison above is not the last word, and we want to be straight about that.
But notice what those comparisons are against. Both are against OpenAI's own previous model, not against Fable 5.1. Nobody has published a like for like token consumption comparison between Astra and Fable 5.1 on the same coding tasks, which is exactly the number that would settle this.
We can at least state the bar it has to clear. To break even against Fable 5.1 on the session above, Astra needs to use around 28 percent fewer tokens. Once the long context multiplier applies, it needs around 64 percent fewer. The first is plausible. The second would be remarkable.
4. So what would we actually use
Being useful here means answering rather than listing considerations, so:
For agentic work on a large existing codebase, we would reach for Fable 5.1 today. Not because of any single benchmark, but because the independent harness inclusive index puts it ahead, and because the cache economics compound in exactly the pattern that work produces. The benchmark margins between them are small enough to be noise. The cost difference is structural.
For computer use tasks that happen to involve code, driving a browser, operating desktop tooling, running frontend checks against a real interface, Astra looks genuinely stronger and it is not close. That was the substance of our reading of the Astra launch: the model is a specialisation jump into computer use and long horizon operation rather than a general intelligence jump. If your coding work is really operating tooling, that lands in Astra's territory.
If you are already inside one ecosystem, the harness is worth more than the margin. Codex and Claude Code are not interchangeable wrappers, and the Artificial Analysis result is partly a statement about them. Switching model means switching harness, and a two point benchmark gap does not pay for relearning a workflow.
We should say plainly that we have not yet run Astra against our own repositories. When we do, we will publish what we find, including if it contradicts the recommendation above.
5. The test that actually settles it
Everything above is a prior. Here is how to replace it with evidence, in about a day.
- Take ten real tickets from your own backlog. Not benchmark tasks. Real ones, with the ambiguity and the legacy code intact, weighted towards the kind of work you actually do most.
- Run each model in its own native harness. Astra in Codex, Fable 5.1 in Claude Code. Comparing a model outside its harness measures the wrong thing.
- Use one pass criterion nobody can argue with: did the change merge without a human rewriting it.
- Record turns, retries and correction time, not just the final result.
- Divide the bill by merged pull requests. Cost per merged PR is the only number that decides anything, and it is the same discipline we applied to model tiers in the Kimi K3 note and to routing in the small language models note.
Two things that will distort the result if you let them. Run both at comparable effort settings, because maximum effort on one against a default on the other is not a comparison. And check your cache hit rate is actually high in both, since a badly structured prompt destroys the economics that this entire analysis turns on.
If you want that run properly against your own codebase rather than against a leaderboard, it is a short piece of work with an unusually clear answer at the end. Talk to us, or see how we build systems for businesses.
6. Sources
- OpenAI, GPT-6 Astra announcement, for the coding benchmark table and footnotes, and the API model reference.
- Artificial Analysis, benchmarking GPT-6 Astra, for the Coding Agent Index results and token efficiency measurements.
- Anthropic, Claude platform pricing and the Claude Fable page.
- VentureBeat, Claude Fable 5.1 and Mythos 5.1 arrive with a 75 percent cost reduction for cache reads.
The cost figures above are computed from published list prices on a stated workload, not measured on production traffic, and the assumptions are in the text so you can substitute your own. Prices in this market change monthly. Benchmark results are as published by OpenAI and Artificial Analysis; we have not reproduced either, and we have not yet run GPT-6 Astra on our own code.
This paper sits in our Engineering track, alongside the foundation models, benchmark and operations threads. The full library is at Research.