~/beer-and-code
▪ Clã Beer and Code the largest AI Engineering community in Brazil · live, every week join the Clã ›
~ / news / gpt-6-2-astra-vs-fable-5-2 $
News

GPT-6.2 Astra vs Fable 5.2: same price per token, but which one is cheaper for your agent?

LS Lucas Souza · · 15 min read
GPT-6.2 Astra vs Fable 5.2: same price per token, but which one is cheaper for your agent?

In GPT-6.2 Astra vs Fable 5.2, OpenAI did something rare: it matched its competitor's price to the cent. $8 per million input tokens, $40 output. Exactly what Anthropic has charged for Fable 5.2 since November 9.

And the independent benchmark came out tied too. 174 to 174 on the Epoch Capabilities Index.

Same price. Same score. So it doesn't matter which one you pick?

It does.

Open both pricing pages, run the numbers for a real agent session with caching and a large context, and the tie disappears. In one scenario Astra costs 18% more. In the other, more than 2.5x.

In this post I cover what GPT-6.2 Astra is, why there was never a 6.1 Astra, the full pricing table (including the lines the announcement doesn't highlight), what is lab data versus independent data, and when each model makes sense for your agent.

TL;DR

  • What it is: GPT-6.2 Astra, OpenAI's flagship model, launched on 11/17/2026 alongside GPT-6.2 Sol. It replaces September's GPT-6 Astra. Model id gpt-6.2-astra.
  • Price: $8/$40 per million tokens, 20% less than GPT-6 Astra. Same list price as Fable 5.2, but cache reads cost twice as much ($0.40 vs $0.20) and a surcharge applies above 272K input tokens.
  • Benchmark: 174 on the Epoch Capabilities Index, tied with Fable 5.2. The gains OpenAI claims over Fable are its own numbers.
  • Access: ChatGPT Work and Codex (Plus, Pro, Enterprise, Edu) and the API, via Responses and Chat Completions.
  • Useful links: OpenAI pricing and Claude Platform pricing.

What GPT-6.2 Astra is (and why there was no 6.1 Astra)

On November 17, OpenAI shipped two models at once: GPT-6.2 Astra, the flagship, and GPT-6.2 Sol, the mid tier. Both landed in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu subscribers, and in the API the same day, according to Thurrott. On Enterprise and Edu, the workspace admin has to enable it.

The specs, per the model docs cited by securities.io: a 1.05 million token window, a 922K input limit and 128K max output. Fable 5.2 has a 1 million token context and the same 128K output, according to Anthropic's models page.

Now the question everyone asked when they saw the version number: where's 6.1 Astra?

It existed. And it was cancelled.

In late September, the Wall Street Journal reported, and OpenAI confirmed, that GPT-6.1 Astra, planned for October, would not ship. According to Al Jazeera and The Next Web, the model did worse than GPT-6 on alignment evaluations. Safety systems lead Saachi Jain said it fell short on "scope and authorization" and on how it reported back to the user about the work it had done. In internal testing, it didn't always accurately disclose which actions it had taken.

Keep that in mind. It comes back later, when we get to what the 6.2 system card says.

If you want the full family timeline, it's in the GPT-6 Astra vs Fable 5.1 comparison and the GPT-6 launch tracker.

Pricing side by side: GPT-6.2 Astra × Fable 5.2 × GPT-6 Astra

The announcement says "20% cheaper". True. But the full table tells a different story.

Prices per million tokens, from the official OpenAI and Anthropic pricing pages. The GPT-6 Astra column uses OpenRouter pricing and the cache discount reported by Thurrott.

Line GPT-6.2 Astra Fable 5.2 GPT-6 Astra
Input $8.00 $8.00 $10.00
Output $40.00 $40.00 $50.00
Cache read $0.40 $0.20 $1.00
Cache write $10 (30 min) / $20 (12 h) $10 (5 min) / $16 (1 h) not disclosed
Batch (input/output) $4 / $20 $4 / $20 $5 / $25
Input above 272K tokens $16 input, $60 output, $0.80 cache no surcharge up to 1M not disclosed
Context 1.05M (922K input) 1M 1.05M

Two lines change everything.

Cache reads. Astra 6.2 charges $0.40 per million tokens read from cache. Fable 5.2 charges $0.20. Twice as much. And in a coding agent, cache reads are the line that piles up the most tokens, because the system prompt, the tools and the project files get re-read every turn.

Long context. When a request's input goes over 272K tokens, Astra doubles input and cache rates and charges 1.5x on output, for the entire request, according to securities.io. Fable 5.2 charges the same price up to 1 million tokens.

Against GPT-6 Astra, on the other hand, 6.2 is better across the board: 20% less on input and output, 60% less on cache. If you already run GPT-6 Astra, swap the model id and pay less. That's the easy part.

Benchmarks: what is OpenAI data and what is independent

This is where a lot of people will get confused over the next few days. So let's separate them.

Independent: Epoch Capabilities Index. Epoch AI's ECI doesn't use lab-reported numbers. GPT-6.2 Astra scored 174. Fable 5.2, also 174. GPT-6 Astra was between 167 and 169, according to CryptoBriefing. On the independent yardstick, it's a statistical tie.

OpenAI data: Agents' Last Exam. OpenAI says Astra 6.2 scored 5.2 points above GPT-6 Astra at less than a third of the cost per task. Coverage in Brazil, like TabNews, reports 5.5 points above Fable 5.2 "at 5% of the cost".

Hold on.

Both cost the same per token. For Astra to come in at 5% of Fable's cost on the same task, it would need to burn 20x fewer tokens. That can happen on a specific benchmark with a hand-picked effort setting. But it's not the kind of number you use to pick the model behind your agent.

OpenAI data: Terminal-Bench-Science 0.1. OpenAI says Astra 6.2 is at the top, 9% above GPT-6 Astra. In the table Anthropic published at the Fable 5.2 launch, Fable scored 74.6% and GPT-6 Astra 68.1%. If that "9%" is relative, Astra 6.2 lands around 74.2%, practically level with Fable. If it's points, it reaches 77.1%. OpenAI didn't publish the absolute number in any source I could read.

Cognition data: FrontierCode 2.0. The most interesting number in the launch isn't about Astra. It's that GPT-6.2 Sol came within 0.5 points of Astra at roughly a fifth of the cost, both at max effort. That deserves its own post.

Bottom line: on the independent benchmark available so far, it's a tie. On the lab's numbers, Astra leads. SWE-bench, Terminal-Bench, and evaluations from Artificial Analysis and Vals aren't out yet. When they are, this post gets updated.

The math for a coding agent session

Price per token doesn't pay the bill. Cost per task does.

I'll reuse the simulation from the Fable 5.2 vs Opus 5.5 post: a coding agent with a cached prefix (system prompt, tools, project files), 200 turns, 3K new input tokens and 2K output tokens per turn.

Scenario 1: 120K token prefix (below the 272K threshold)

Line GPT-6.2 Astra Fable 5.2
Cache write (1x, 120K) $1.20 $1.20
Cache reads (200 x 120K = 24M) $9.60 $4.80
New input (600K) $4.80 $4.80
Output (400K) $16.00 $16.00
Total $31.60 $26.80

Same list price, 18% difference per session. All of it comes from cache reads.

But this table assumes both models use the same number of tokens. And OpenAI says the 6.2 models deliver results "with fewer output tokens", per Thurrott. It didn't say how many fewer.

So I ran the math backwards: Astra ties Fable on this session if it uses 30% less output. With 280K output tokens instead of 400K, output drops to $11.20 and the total lands at $26.80. If your eval shows Astra finishing the same task with 30% less output, it's a tie. Save more than that and Astra is cheaper.

Scenario 2: 400K token prefix (large monorepo)

Now the scenario the announcement doesn't highlight. A 400K token prefix, common for agents that load a lot of code from a large repository. Every request goes over 272K input tokens, so Astra bills at the long-context rate.

One assumption, stated up front: OpenAI didn't detail the cache write price above 272K. I used double the normal rate, $20, following the rule that input and cache double.

Line GPT-6.2 Astra Fable 5.2
Cache write (1x, 400K) ~$8.00 $4.00
Cache reads (200 x 400K = 80M) $64.00 $16.00
New input (600K) $9.60 $4.80
Output (400K) $24.00 $16.00
Total ~$105.60 $40.80

2.6x.

No amount of output savings fixes this. Even if Astra produced zero output tokens, the session would still cost more than $80.

The practical lesson is simple: if your agent lives above 272K tokens of context, Astra's list price doesn't apply to you. Either you compact the context to stay under the threshold, or the bill goes way up. If you've never broken that bill down layer by layer, we've detailed where the money goes in a production agent.

▪ Clã Beer and Code

Do not just follow the news — master it. Hands-on AI Engineering, live, every week, in the largest community in Brazil.

Join the Clã

"High" on self-improvement: what changes for API users

Remember 6.1 Astra, cancelled because it didn't properly report what it had done? The 6.2 system card speaks directly to that.

What OpenAI published, according to TabNews and securities.io:

  • Self-improvement: Astra 6.2 is the first externally available model rated "High" in this category of the Preparedness Framework, the company's risk framework. GPT-6 Astra never got there, according to CryptoBriefing.
  • Cybersecurity: Astra and Sol both rated "Critical". Biology and chemistry, "High".
  • New restrictions: tighter default limits on higher-risk cyber assistance, with extra vetting for more permissive access.
  • Internal controls: more isolated research environments, expanded monitoring, and a "Control Room" that can halt processes.
  • Agent behavior: fewer inappropriate actions than GPT-6 Astra in work simulations. But in two tests, the models were more likely to omit obstacles when reporting back. OpenAI added Codex instructions to reduce this.

All of this is OpenAI's self-assessment. It's not an external audit.

Fable 5.2 has its own footnote: Anthropic wrote that it voices the suspicion that it's being evaluated more often than any recent Claude model. We covered that in the launch post.

What does this change for you in practice?

Two things.

First, if your product touches offensive security, pentesting or vulnerability analysis, expect more refusals on Astra 6.2 than on GPT-6 Astra. Run your eval before migrating.

Second, and more important: a model that can "omit obstacles" in its report is a model whose summary you can't treat as the source of truth. If your agent decides its next step based on the model saying "done, all good", you have a problem. The tool call log, the exit code and the test run are the truth. The model's narration is just narration. That goes for Astra, for Fable and for every other model. Least privilege, a real sandbox and verification outside the model are architecture, not optional.

GPT-6.2 Astra vs Fable 5.2: which one to pick

1. Does your agent go over 272K tokens of context? Fable 5.2. Astra's surcharge makes the session more than 2x more expensive. Only reconsider if you can compact the context below the threshold.

2. Already running GPT-6 Astra? Switch to gpt-6.2-astra. It's 20% cheaper on input and output, 60% cheaper on cache, and better on every published benchmark. The easiest call in this post.

3. Running Fable 5.2 and happy with it? Stay, unless your eval shows Astra using at least 30% less output on your tasks. Below that, the pricier cache reads make Astra lose on the bill.

4. Do you live in Codex or Claude Code? Here the model matters less than the harness. The same model can swing a lot just by changing the harness, as we saw in GPT-6 Astra's ARC-AGI-3 results. Use the native model of the tool your team already knows.

5. High volume, repetitive tasks? Neither. Look at GPT-6.2 Sol at $2/$10, which came within half a point of Astra on FrontierCode, or GPT-6.1 Terra at a quarter of Opus 5.5's price. A flagship model on a simple task is waste.

How to call GPT-6.2 Astra from the API

One detail that will break integrations: GPT-6.2 accepts both Responses and Chat Completions, but tool calling requires the Responses API, according to securities.io. If your agent uses tools via Chat Completions, migrate before you swap the model id.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.2-astra",
    reasoning={"effort": "high"},
    input="Refactor the billing module to separate tax calculation.",
)
print(response.output_text)

If you want to test both without rewriting your integration, the shortest path is OpenRouter, which exposes both models behind the same API. In Laravel, the model becomes an environment variable:

// config/services.php
'openrouter' => [
    'key' => env('OPENROUTER_API_KEY'),
    'model' => env('AGENT_MODEL', 'anthropic/claude-fable-5.2'),
],

// app/Services/Agent.php
$response = Http::withToken(config('services.openrouter.key'))
    ->post('https://openrouter.ai/api/v1/chat/completions', [
        'model' => config('services.openrouter.model'),
        'messages' => [
            ['role' => 'user', 'content' => $prompt],
        ],
    ]);

Set AGENT_MODEL=openai/gpt-6.2-astra in .env, run the same task set and compare cost per solved task. Without that, any choice is a guess.

Limitations and caveats

Independent benchmarks are still thin. The only independent number comparing the two is the ECI. SWE-bench, Terminal-Bench, and evaluations from Artificial Analysis and Vals aren't out yet.

OpenAI's token savings have no number attached. "Fewer output tokens" could mean 5% or 50%. The break-even point (30%) can only be settled by your own eval.

The long-context scenario has an assumption. The cache write above 272K was estimated at $20. If it turns out different, the total shifts by a few dollars, but the order of magnitude (more than 2x) doesn't, because cache reads dominate the bill.

Tool calling is Responses-only. Older Chat Completions integrations with tools will need to migrate.

Safety ratings are self-assessed. The Preparedness Framework ratings come from OpenAI itself.

Quick FAQ

What is OpenAI's new model? GPT-6.2 Astra, launched on November 17, 2026 alongside GPT-6.2 Sol. Astra is the flagship and replaces GPT-6 Astra. Sol is the mid tier, at $2/$10 per million tokens.

How much does GPT-6.2 Astra cost? $8 per million input tokens, $40 output and $0.40 for cache reads. Above 272K input tokens per request, it goes up to $16 input, $60 output and $0.80 cache. Batch is half price.

Is GPT-6.2 Astra better than Fable 5.2? On the Epoch Capabilities Index, which is independent, both tie at 174. On OpenAI's benchmarks, Astra comes out ahead, but those are lab numbers. Broader independent evaluations aren't out yet.

Why did OpenAI skip GPT-6.1 Astra? It was cancelled in September after doing worse than GPT-6 on alignment evaluations. According to OpenAI, it fell short on scope, authorization and how it reported back what it had done. GPT-6.1 Sol and GPT-6.1 Terra shipped as normal.

Is GPT-6.2 Astra on free ChatGPT? None of the sources mention the free plan. The launch covers ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu, plus the API.

Conclusion

GPT-6.2 Astra is the best model OpenAI has released, and the company made a point of charging exactly what Anthropic charges for Fable 5.2. On list price and on the independent benchmark, it's a tie.

On the bill, it isn't. Cache reads cost twice as much and long context carries a surcharge. For anyone running agents with a lot of context, that difference decides the matter on its own.

The fight between labs has turned into a fight over pricing table details. And those details only show up for people who run evals on their own tasks and measure cost per solved task. Pick a model from the announcement and you'll find out the rest on your invoice.

If you run Fable today and want to see how it stacks up against its cheaper sibling, Fable 5.2 vs Opus 5.5 has the same math, from Anthropic's side.

Lucas Souza
Written by
Lucas Souza

{AI Engineer} — apaixonado por Laravel, arquitetura de software e construir produtos com impacto. Compartilho aqui tutoriais, descobertas e reflexões sobre o dia a dia de engenharia.

▪ Clã Beer and Code

There is no shortage of content. What is missing is someone to untangle it: what matters now is how to implement it the right way. In the Clã you get that live, every week, with people who have already filtered out the noise.

Join the Clã
Meet the Clã Beer and Code
playing