Two models, one price tag: $10 per million input tokens, $50 per million output tokens. GPT-6 Astra shipped on September 3, Claude Fable 5.1 on September 1. Identical sticker prices, so the comparison looks simple.
It is not. The sticker is the same, the bill is not. Run the same work through both and what you pay can double or halve depending on the shape of your workload.
The Short Answer
- Long-running coding agents (Claude Code, extended sessions, loops that re-read the same repo): Fable 5.1. Cache reads are four times cheaper, and that is where the bill comes from in this kind of work.
- One-shot heavy tasks (one question, one analysis, one fix): Astra. It finishes the same job on noticeably fewer tokens.
- Computer and browser automation, math, scientific command-line work: Astra, by a clear margin.
- Single requests above 300K tokens: Fable 5.1. Astra has a 272K token cliff, and crossing it raises the rate.
- Access today, no waiting list: Fable 5.1. Astra is still on a phased rollout.
Pricing: Same Sticker, Different Bill
Input and output really are identical. The gap opens on the third row:
| Item (per 1M tokens) | GPT-6 Astra | Claude Fable 5.1 | Gap |
|---|---|---|---|
| Input | $10.00 | $10.00 | None |
| Output | $50.00 | $50.00 | None |
| Cache read | $1.00 | $0.25 | Fable 4x cheaper |
| Cache write | $12.50 | $12.50 | None |
| Long-context surcharge | Above 272K | None | Fable's favour |
The cache read row is the heart of this comparison. Anthropic cut Fable 5.1's cache read price from $1.00 to $0.25, which is just 2.5% of its own $10 input price. Most other Claude models use a 10% multiplier, and so does Astra.
Why does this matter so much? In an agent session the same system prompt, the same tool definitions and a growing conversation history get resent on every turn. Across a 50-turn run, that repeated block is the bulk of the bill, and it is served from cache. Anthropic's own estimate is that the cut lowers effective cost by roughly 25% on typical workloads and up to 45% on heavily agentic ones.
The 272K Token Cliff
Astra's context window is 1,050,000 tokens against Fable 5.1's 1,000,000. On paper Astra is slightly ahead. But Astra has a threshold:
Once a request's input passes 272,000 tokens, the price changes for the entire request.
| Input size | Astra input | Astra output | Fable input | Fable output |
|---|---|---|---|---|
| Below 272K | $10 | $50 | $10 | $50 |
| Above 272K | $20 | $75 | $10 | $50 |
The important detail: this is not a blended rate. Send 273K tokens and you do not pay the cheap rate on the first 272K and the expensive rate on the rest. The whole request moves to the higher tier. Cache reads jump from $1.00 to $2.00 the same way.
Fable 5.1 has no such threshold. The entire 1M window bills at standard rates.
Practical takeaway
If you feed whole codebases, long PDF sets or wide log dumps in a single request, watch the 272K line on Astra. The moment a request crosses it, that request costs close to twice as much.
Benchmark Comparison
| Benchmark | GPT-6 Astra | Claude Fable 5.1 | Leader |
|---|---|---|---|
| FrontierMath Tier 4 v2 | 97.6% | 87.8% | Astra +9.8 |
| GPQA Diamond | 96.0% | 93.7% | Astra +2.3 |
| ScreenSpot-Pro | 92.7% | 87.3% | Astra +5.4 |
| DeepSWE v1.1 | 74.1% | 67.4% | Astra +6.7 |
| AutomationBench | 41.4% | 31.4% | Astra +10.0 |
| Terminal-Bench 4.0 | 57.7% | 55.8% | Astra +1.9 |
| ExploitBench | 100% | 70% | Astra +30 |
| Humanity's Last Exam (tools) | 57.2% | 65.0% | Fable +7.8 |
| SciCode | 56% | 63% | Fable +7 |
| GDPval-AA v2 (score) | 1580 | 1764 | Fable +184 |
| AA-Briefcase (score) | 1562 | 1662 | Fable +100 |
The picture is not one-directional. Astra leads on math, scientific reasoning, screen understanding and vulnerability testing. Fable 5.1 leads on long tool-assisted reasoning and on knowledge-work measures. GDPval and AA-Briefcase both try to score real professional output, and Fable wins both.
One caveat worth repeating: none of these scores were taken under matched conditions. OpenAI says it runs its models at maximum effort, Anthropic notes it used different versions on some tests. The table is a footnoted compilation, not a leaderboard.
Which One Codes Better?
This is the question everyone asks, and the answer is blurrier than you would like.
Astra leads on the discrete coding benchmarks OpenAI published side by side, with a 6.7 point gap on DeepSWE v1.1. But the Coding Agent Index, which measures end-to-end agent performance, flips it: Fable 5.1 running inside Claude Code tops the list at 70, while Astra inside Codex sits at 67.
How much of that 3 point gap belongs to the model and how much to the scaffolding? Nobody knows. The two models ran in different harnesses, Codex against Claude Code, so this is as much a tooling comparison as a model comparison.
The honest summary: for day-to-day coding there is no quality chasm between these two. What separates them is the shape of the pricing and the tool you already use.
Speed, Tokens and Cost Per Task
| Measure | GPT-6 Astra | Claude Fable 5.1 |
|---|---|---|
| Output speed | 54 tokens/s | 68 tokens/s |
| End-to-end response time | 344 s | 293 s |
| Output tokens per task | 27,000 | 78,000 |
| Cost per intelligence-index task | $1.67 | $3.76 |
Fable 5.1 emits more tokens per second and finishes sooner. But Astra solves the same task on roughly a third of the tokens. Since output is the most expensive line item, on one-shot work where caching never kicks in Astra's bill drops to less than half.
Put simply: Fable is fast but verbose, Astra is slow but terse. Which one is cheap depends on how many turns your work takes.
Computer Use and Safety
Astra's clearest advantage is not a benchmark row, it is computer use. It leads ScreenSpot-Pro by 5.4 points and AutomationBench by 10. OpenAI also reports average time per task dropping from 75 minutes to 40.
Safety numbers point the same way: the misbehaviour rate during computer use is 2.4% for Astra against 9.5% for Fable 5.1. If a model is clicking around a browser on your behalf, that gap is not academic.
There is a cost to this. Astra is the first model to cross OpenAI's critical cybersecurity threshold under its Preparedness framework, so the standard-access version refuses work such as vulnerability discovery.
Context, Knowledge Cutoff and Access
| Spec | GPT-6 Astra | Claude Fable 5.1 |
|---|---|---|
| Context window | 1,050,000 | 1,000,000 |
| Max output | 128,000 | 128,000 |
| Knowledge cutoff | April 30, 2026 | June 2026 |
| Access | Phased rollout | General availability day one |
| Open weights | No | No |
Three Scenarios, Three Real Bills
Enough theory. Same job, both models.
Scenario 1: long coding agent. A 50-turn session, each turn reading 200K tokens from cache, adding 5K new input, producing 3K output.
| Item | Astra | Fable 5.1 |
|---|---|---|
| Cache reads (10M) | $10.00 | $2.50 |
| New input (0.25M) | $2.50 | $2.50 |
| Output (0.15M) | $7.50 | $7.50 |
| Total | $20.00 | $12.50 |
Fable 5.1 is 37% cheaper.
Scenario 2: one-shot heavy task. No caching, 50K tokens of input, each model answering at its natural length.
| Item | Astra | Fable 5.1 |
|---|---|---|
| Input (0.05M) | $0.50 | $0.50 |
| Output | $1.35 (27K tokens) | $3.90 (78K tokens) |
| Total | $1.85 | $4.40 |
Astra is 58% cheaper.
Scenario 3: large codebase, single request. 400K tokens in, 20K tokens out. Astra crosses the 272K cliff here.
| Item | Astra | Fable 5.1 |
|---|---|---|
| Input (0.4M) | $8.00 (at $20 tier) | $4.00 |
| Output (0.02M) | $1.50 (at $75 tier) | $1.00 |
| Total | $9.50 | $5.00 |
Fable 5.1 is 47% cheaper.
Three scenarios, two different winners, one identical price tag.
So Is This AGI?
This was the loudest thread around Astra's launch. OpenAI's Greg Brockman describes the term as "a mission or spirit level concept, not a contractual trigger" and leaves the call to the reader. The headline ARC-AGI-3 score of 98.6% came from a bespoke harness; the same model scores 62.7% on the standard one.
Anthropic makes no such claim. It positions Fable 5.1 as the most advanced model for coding and knowledge work and does not use the AGI label at all.
For the purposes of choosing between them, the label debate changes nothing. The three scenarios above do.
Which One for Which Job?
- Long agent sessions, loops that reread the same context: Fable 5.1. The cache gap alone decides it.
- Single requests above 300K tokens: Fable 5.1. Astra's threshold surcharge makes this expensive.
- Computer and browser automation: Astra. Both the score and the misbehaviour rate favour it.
- Math, scientific research, CAD: Astra. A 10 point gap on FrontierMath is not something a budget closes.
- Knowledge work, reports, professional deliverables: Fable 5.1. It leads both GDPval and AA-Briefcase.
- One-shot heavy questions: Astra. A third of the tokens, less than half the bill.
- Starting today: Fable 5.1. Astra's rollout is still phased.
- High-volume production workloads: neither. For classification and summarisation, Gemini 3.8 Flash sits at a tenth of the price.
Conclusion
The real lesson here is not which model wins. It is that two models carrying the same $10/$50 tag can produce bills that differ by more than 50% depending on the shape of the work.
Input and output prices are no longer where model selection is decided. Cache read price, the long-context threshold and tokens spent per task are the three line items that matter.
Which one are you running, and did the cache pricing change your answer?
Originally published on Proje Defteri, where this post is kept up to date.
Also on the site: more English posts on AI models, Arduino and IoT, and free browser tools for makers and developers - token counter, LLM cost calculator, LCD and OLED bitmap converters.
Your support means a lot! ✨ Comment 💬, like 👍, and follow 🚀 for future posts!
Top comments (0)