GPT-6.2 Astra and Claude Fable 5.2 now cost exactly the same per token. Per finished task, one can cost a sixth of the other, or the gap can reverse, depending on the work and on how hard you let each model think. This guide works out which is which, with the arithmetic.
On November 17, 2026, OpenAI released GPT-6.2 Astra at $8 per million input tokens and $40 per million output tokens - OpenAI Developers. Eight days earlier, on November 9, Anthropic had released Claude Fable 5.2 at the same $8 and $40, a 20% cut from Fable 5.1 - Anthropic. For the first time, the two labs' flagships share a rate card.
They do not share a bill. On the Artificial Analysis Intelligence Index, Fable 5.2 at max effort scores 65 at $26.54 per task, and GPT-6.2 Astra at max effort scores 62 at $4.00 per task - Artificial Analysis. Three points apart, at about one sixth of the cost. That single comparison is already the most quoted number of the week, and on its own it suggests an easy conclusion: Astra is the value pick, Fable the luxury.
The full data is more interesting than that. At xhigh, the setting both labs reserve for their hardest long-running work, the two models score the same on that index, and the cost gap is still almost six to one. On a coding benchmark that OpenAI itself charted, Fable posts the highest score of any model. On one independent leaderboard Fable at its default setting solves seven points more terminal tasks than Astra's best, and on another it is cheaper per game won. And Astra launched to a rough reception, with investor Matt Shumer calling the new models "essentially unusable" - VentureBeat. A model that is cheap per attempt but needs a human to keep pushing it is not cheap per finished job.
This guide is the head-to-head. It lays the two rate cards side by side and shows where they quietly differ, explains from first principles why identical prices produce a six-fold gap, prices both models at every effort level, breaks the gap down by type of work across more than a dozen independent and vendor benchmarks, and builds a cost-per-task model you can run against your own workload. It also covers the subscriptions, Copilot credits and Cursor plans most people actually buy these models through, and the market moves of this week that change the math. For each model on its own, see our deep dives on GPT-6.2 Astra and Sol and on Fable 5.2 against Opus 5.5.
This guide reflects prices, plans and benchmark results as published on November 19, 2026. Both labs adjust effort tuning, plans and promotional rates often, so verify current details before committing a budget.
Contents
- The Short Answer: Cost per Task by Type of Work
- The Rate Cards: Same Headline, Different Fine Print
- Why Identical Prices Produce a Six-Fold Gap
- Effort Is the Real Price List
- Where Each Model Actually Wins
- What the Launch Charts Show When You Read the Data
- Seven Independent Leaderboards, One Pattern
- Refusals, Fallbacks and the Safety Tax
- Speed, Waiting and the Price of Fast Modes
- A Cost-per-Task Model You Can Reuse
- Buying Through Plans: ChatGPT, Claude, Copilot and Cursor
- The Reception: "Essentially Unusable" and "A Turn Can End Early"
- The Market Around the Decision This Week
- Which Model to Run: A Decision Guide
- Outlook: Where the Gap Goes Next
1. The Short Answer: Cost per Task by Type of Work
Before the detail, the verdicts. Each row names the model that is cheaper per finished task on that kind of work (not per attempt, not per token), with the evidence behind it. "Finished" matters: a model that fails more often has to be run again, checked, or replaced by a person, and all of that is part of its real cost. Every figure in this table is explained and sourced in the sections below.
| Type of work | Cheaper per finished task | The evidence in one line |
|---|---|---|
| Long-horizon professional workflows | GPT-6.2 Astra | Agents' Last Exam: 47.5% pass rate on 2.6M output tokens vs Fable's 46.9% on 28.2M |
| SaaS automation across apps | GPT-6.2 Astra | AutomationBench: level on quality, Astra about 5.6x cheaper per task |
| Terminal and DevOps tasks | GPT-6.2 Astra (Fable solves more) | Vals Terminal-Bench 4.0: Astra 64.6% at $2.33, Fable 71.7% at $13.64 |
| Abstract reasoning puzzles | GPT-6.2 Astra | ARC-AGI-2: 95.8% at $0.50 per task vs 93.8% at $0.98 |
| Legal deliverables | GPT-6.2 Astra (vendor data) | Harvey LAB-AA on OpenAI's chart: 15.0% vs 7.2% pass rate at a sixth of the cost |
| Finance, legal and tax agents | Split: Astra per solved task, Fable on accuracy | Vals Index: Fable 71.3% at $17.94 per test, Astra 67.7% at $10.68 |
| Merge-ready code in real repos | Close: Fable at high is competitive | FrontierCode 2.0 on OpenAI's chart: Fable high 45.3% at $6.72 vs Astra max 44.2% at $5.97 |
| Codebase comprehension and refactoring | Fable 5.2 (no cost data) | Scale SWE Atlas: 80.55 vs 60.46 |
| High-stakes factual research | Fable 5.2 | AA-Omniscience 67 vs 50; SimpleQA Verified 94% vs 79% |
| Long interactive environments | Depends on the harness | ARC-AGI-3: Fable cheaper per game on the standard harness, Astra 4.5x cheaper on the provider harness |
The pattern is consistent enough to state as a rule of thumb. GPT-6.2 Astra is the cheaper model per finished task wherever the work is execution: running commands, moving data between systems, working through long checklists of professional steps. Claude Fable 5.2 earns its premium where the work is judgment under uncertainty: factual research where hallucination is the expensive failure, deep comprehension of a codebase, and the hardest reasoning problems. And on everyday code changes, the category most teams care about most, the two are close enough that your own codebase, prompts and effort setting will decide it, not the leaderboard.
2. The Rate Cards: Same Headline, Different Fine Print
The headline prices match, but almost every secondary price differs, and in agent workloads the secondary prices are the ones you actually pay. The table below is assembled from OpenAI's model page and pricing page and from Anthropic's pricing documentation - OpenAI Developers:
| Price or policy | GPT-6.2 Astra | Claude Fable 5.2 |
|---|---|---|
| Input (per million tokens) | $8 | $8 |
| Output (per million tokens) | $40 | $40 |
| Cache read | $0.40 (0.05x input) | $0.20 (0.025x input) |
| Short cache write | $10 (30-minute lifetime) | $10 (5-minute lifetime) |
| Long cache write | $20 (12-hour lifetime) | $16 (1-hour lifetime) |
| Prompts over 272K tokens | Whole request repriced: $16 in, $0.80 cached, $60 out | No surcharge anywhere in the 1M window |
| Batch | $4 in, $20 out | $4 in, $20 out |
| Fast mode | 2x price | 2x price ($16 / $80), up to 2.5x faster |
| Ultrafast | 3x price until Feb 28, 2027, then 6x | Not offered |
| Discounted background windows | 30% off (2-hour), 40% off (8-hour) | Not offered |
| Regional processing | +10% | +10% for US-only inference |
| Context / max output | 1.05M (922K max input) / 128K | 1M / 128K |
| Prompt caching | On by default | Opt-in (cache_control) |
| Default effort | Start at medium (OpenAI's guidance) | High on the API, medium in Claude apps |
Five of these differences change real bills, and they cut in both directions.
Fable's cache reads cost half of Astra's. Anthropic prices Fable 5.2 cache hits at 0.025 times the base input price, a deliberately lower multiplier than most of its models, which works out to $0.20 per million - Claude Docs. OpenAI's GPT-6.2 models read from cache at 0.05 times, or $0.40 - OpenAI Developers. Because a well-run agent loop serves 95% or more of its input from cache, this is the most-used price on either card, and Fable wins it.
Astra reprices the whole request above 272K tokens. Once a prompt passes 272,000 input tokens, OpenAI doubles the input and cache rates and charges 1.5 times for output, "for the full request," not only for the tokens above the line - OpenAI Developers. Anthropic does the opposite: "A 900k-token request is billed at the same per-token rate as a 9k-token request" on its current models. Long-running agents whose context grows past a quarter of a million tokens therefore pay a step-change on Astra and nothing extra on Fable, unless you compact the context to stay under the line.
Caching is automatic on Astra and opt-in on Fable. OpenAI enables prompt caching by default for supported models. Anthropic caches only when the request carries cache_control, either as explicit breakpoints or as a single top-level field that turns on automatic caching - Claude Docs. A Fable integration that forgets it pays the full $8 for every re-read of its context, forty times the cached price. This is the single most expensive configuration mistake available in this comparison, and it is entirely on the Fable side.
Both charge for cache writes now, on different clocks. Writing new context into the cache costs 1.25 times the input price on both. The difference is lifetime: Astra's default write lasts 30 minutes and its long option 12 hours (at 2.5 times input), while Fable's lasts 5 minutes and its long option one hour (at 2 times input). An agent that pauses for a human for ten minutes keeps its Astra cache and loses its default Fable cache, and pays to write it again.
OpenAI offers more ways to trade time for money. Both offer a 50% batch discount. GPT-6.2 also gets discounted background completion windows, 30% off for results within two hours and 40% off within eight, as an alternative to the Flex tier it does not support - OpenAI Developers. At the other end, Ultrafast costs three times standard until February 28, 2027, and six times from March 1. Fable's only speed option is fast mode at twice the price.
Add these up and a clear picture emerges: token for token, in the long agent loops where cost matters most, Fable 5.2 is actually the cheaper model. Section 10 shows that with a worked model. Which means the entire per-task gap in Astra's favor has one source, and it is the subject of the next section.
3. Why Identical Prices Produce a Six-Fold Gap
Start from what an API bill actually is: the price of a token multiplied by the number of tokens the model decides to spend. The labs publish the first number on their rate cards. The second number only appears in your usage logs, and it is set by the model, not by you. Since November 17 the first number is the same for both models, so every dollar of difference between them lives in the second.
Artificial Analysis is one of the few places that publishes the second number for the same workload. To run its Intelligence Index at max effort, Claude Fable 5.2 generated 275 million output tokens and read 28.3 billion input tokens - Artificial Analysis. GPT-6.2 Astra ran the identical suite on 65.8 million output tokens and 2.16 billion input tokens - Artificial Analysis. That is 4.2 times the output and 13 times the input for Fable, on the same tasks, at the same price per token.
Where the money in one task actually goes
Vals AI publishes the raw token totals behind its Terminal-Bench 4.0 results, which makes it possible to rebuild a task's bill line by line at list prices - Vals AI. The table below is our arithmetic on those totals (66 tasks), and for Fable it reproduces Vals' own reported cost per test to the cent, which is a useful check that the method is right:
| Line of the bill, per task | Claude Fable 5.2 | GPT-6.2 Astra |
|---|---|---|
| Cache reads (re-reading earlier context) | $4.01 | $1.18 |
| Cache writes (new context saved for reuse) | $3.84 | $1.00 |
| Output, including reasoning | $6.72 | $2.25 |
| Uncached input | under $0.01 | under $0.01 |
| Total | $14.57 | $4.42 |
| Share of input served from cache | 98.1% | 96.7% |
| Average turns per task | 85.6 | 35.6 |
Vals reports $14.56 for Fable and $4.69 for Astra; the small Astra gap may come from requests that crossed into OpenAI's pricier long-context tier, which our flat-rate arithmetic ignores. Three things stand out. Almost nothing is billed at the full $8 input price: in a well-cached agent loop, the "input price" on the rate card is close to irrelevant, and the cache prices are what you pay. Output, including the reasoning you never see, is the largest single line for both models. And Fable's bill is bigger on every line not because any price is higher (its cache read is half of Astra's) but because every line holds more tokens.
Why Fable reads and writes so much more
Three mechanisms explain the volume, and they matter because each one is something you can partly control.
Thinking is always on. On Fable 5.2, adaptive thinking cannot be switched off; effort is the only dial - Claude Docs. Anthropic also warns that a prompt line asking for less deliberation does not stop the model thinking at medium effort and above, and that at high and above it thinks before almost every reply. Every one of those thinking tokens is billed at the output rate.
Turns compound. Agent loops make input grow with the square of the turns. In an agent loop, each turn re-sends everything that came before it: the system prompt, the tools, every earlier tool result and every earlier reply. A task that takes twice as many turns does not read twice as much input; it reads roughly four times as much, because each additional turn is longer than the last. The Vals data above shows exactly this: Fable took 2.4 times as many turns as Astra on the same terminal tasks, and 2.4 squared is 5.8, close to the 6.7 times as much input it actually read. On Artificial Analysis's suite, a 13x input gap against a 4.2x output gap points the same way. Fable's extra cost is mostly a longer trajectory, not a wordier reply.
Delegation multiplies everything. Anthropic notes that how much Fable 5.2 delegates to subagents depends on your harness, that it delegates readily when prompts invite it, and that subagents can account for a large part of what a session costs - Claude Docs. Each subagent starts its own context and its own loop.
OpenAI went the other way on purpose. Its launch post leads with the claim that both new models "deliver better results on demanding tasks with fewer output tokens," and reports that on its internal GDPval v2 benchmark GPT-6.2 Astra scored 6.2 points higher than GPT-6 Astra while using 22% fewer output tokens - OpenAI. Token efficiency is now a headline feature, because in a world where both labs charge $8 and $40, it is the only lever on price that a lab can pull without touching the rate card.
A token is not the same unit on both sides
There is a quieter multiplier underneath all of this. Fable 5.2 uses the tokenizer Anthropic introduced with Claude Opus 4.7, which turns the same text into roughly 30 percent more tokens than Anthropic's earlier models did - Claude Docs. Neither lab publishes how its tokenizer compares with the other's, so the honest statement is that a million Fable tokens and a million Astra tokens are not guaranteed to hold the same amount of text. Benchmark totals like the ones above already include this effect, which is one more reason to compare models on cost per task rather than on price per token.
The speed paradox
Fable generates tokens more than twice as fast as Astra: about 109 output tokens per second against about 49 on Artificial Analysis's measurements - Artificial Analysis. Yet at max effort an average index task took Fable 41.8 minutes and Astra 13.9 minutes. Faster generation loses to fewer tokens. For an agent that a person is waiting on, the minutes are a cost too, and we come back to them in section 9.
4. Effort Is the Real Price List
Both models expose five effort levels, low through max, and the level you choose moves cost per task far more than the choice of model does. Artificial Analysis ran both models at every level on the same suite, which gives a rare like-for-like price list - Artificial Analysis:
| Effort | Fable 5.2 score | Fable 5.2 cost per task | Fable 5.2 time | Astra score | Astra cost per task | Astra time |
|---|---|---|---|---|---|---|
| Low | 54 | $3.10 | 5.5 min | 46 | $0.66 | 1.9 min |
| Medium | 56 | $3.80 | 6.5 min | 57 | $1.62 | 4.5 min |
| High | 62 | $9.08 | 15.1 min | 60 | $2.07 | 6.1 min |
| Xhigh | 62 | $14.83 | 24.4 min | 62 | $2.52 | 7.5 min |
| Max | 65 | $26.54 | 41.8 min | 62 | $4.00 | 13.9 min |
Read the table as a set of price points rather than two products, and a pattern jumps out. Every Fable 5.2 setting except max is beaten on both price and score by some Astra setting. Fable at low (54 for $3.10) loses to Astra at medium (57 for $1.62). Fable at medium (56 for $3.80) loses to Astra at medium too. Fable at high and xhigh (62 for $9.08 and $14.83) tie Astra at xhigh, which costs $2.52. The only point on the chart that Astra cannot reach at any price is Fable at max: 65.
That turns a vague question ("which model is better value?") into a precise one: is the jump from 62 to 65 worth about $24 more per task and 34 more minutes? Measured from the cheapest way to score 62 (Astra at xhigh, $2.52) to the only way to score 65 (Fable at max, $26.54), that is the real premium. Measured within Fable alone, going from xhigh to max costs $11.71 more per task for those same three points.
The defaults are not the same
Most teams never choose an effort level; they inherit one. On the Claude API, Fable 5.2 defaults to high, and Anthropic's own guidance is to start there, step up to xhigh only where you have measured a gain, and "reserve max for measuring the model's ceiling," adding that at max the model "optimizes for capability without regard to token cost" - Claude Docs. In the Claude apps and Claude Code, the default is medium - Anthropic. OpenAI tells new GPT-6.2 integrations to start at medium - OpenAI Developers.
So the comparison most API users will actually live with, without touching a setting, is Fable at high (62 for $9.08 per task) against Astra at medium (57 for $1.62). That is a five-point quality gap for 5.6 times the cost, a very different trade from the headline. And the comparison the headline uses, max against max, pits Fable at the setting its maker describes as a ceiling-measuring tool against Astra at a setting that, on this index, buys nothing over xhigh: Astra scores 62 at both, and max costs $1.48 and 6.4 minutes more per task. OpenAI's own guidance is equally cautious, describing xhigh as something to use "only when your evals show a clear benefit that justifies the extra latency and cost" - OpenAI Developers.
What to do with this: decide the effort level before you decide the model. If your evaluations say medium is enough, Astra at medium is the cheapest credible frontier option in this comparison. If they say you need the strongest result available at any price, Fable at max is the only setting that reaches it. Everything in between is a range where Astra delivers the same index score for a quarter to a sixth of the money.
5. Where Each Model Actually Wins
A single index number averages away the thing you most need to know, which is whether your workload sits where one model is strong. Artificial Analysis publishes the nine evaluations behind its index for both models, and they split cleanly - Artificial Analysis:
| Evaluation (weight in index) | What it tests | Fable 5.2 (max) | Astra (max) | Astra (xhigh) | Leader |
|---|---|---|---|---|---|
| AA-Omniscience (15%) | Factual recall across 42 topics; wrong answers lose points | 67 | 50 | 48 | Fable |
| HLE-Diamond (10%) | 1,000 hard reasoning and knowledge questions | 80.2% | 72.2% | 67.3% | Fable |
| AA-Briefcase (15%) | Multi-week expert knowledge-work projects (Elo) | 1785 | 1643 | 1594 | Fable |
| CritPt v2 Hard (10%) | Research-level physics problems | 76.5% | 71.5% | 70.5% | Fable |
| FrontierCode-AA 2.0 (15%) | Merge-ready changes to real repositories | 48.8% | 45.4% | 49.0% | Split |
| Terminal-Bench 4.0 (10%) | Engineering, sysadmin and data tasks in a terminal | 59.6% | 64.1% | 64.1% | Astra |
| Terminal-Bench-Science (15%) | Scientific workflows in a terminal | 73.3% | 78.1% | 78.6% | Astra |
| GDP.pdf (5%) | Reasoning over long professional documents | 24.2% | 29.8% | 28.0% | Astra |
| AutomationBench-AA (5%) | Multi-app SaaS workflows over REST APIs | 76.4% | 77.2% | 76.1% | Tie |
The descriptions come from Artificial Analysis's methodology, which also explains that AA-Omniscience rewards abstaining over guessing wrong, so a high score means the model knows what it does not know - Artificial Analysis.
The pattern is not random. Fable's lead is concentrated in knowing and reasoning: recalling facts without inventing them (a 17-point gap on AA-Omniscience, the largest in the table), answering expert-level questions, solving hard physics, and producing expert knowledge-work deliverables over long projects. Astra's lead is concentrated in doing: executing multistep work in a terminal, running scientific workflows, and extracting what a long document actually says. On the evaluation closest to everyday software work, merge-ready code changes, they trade places depending on effort, and on SaaS automation they are level.
That matters for cost per task because the index price ($26.54 against $4.00) is an average over all nine. If your agents mostly run commands, edit code and move data between systems, the evaluations that resemble your work show Astra at least as good, and the cost gap is the full four to six times. If your agents mostly research, answer and advise, where a confident wrong fact is the expensive failure, the evaluations that resemble your work favor Fable, sometimes by a wide margin, and the premium starts buying something specific: fewer hallucinations.
Putting a price on the premium
A model that costs more per attempt is cheaper per finished task when it fails enough less often. The break-even is simple to write down: the expensive model pays for itself when its extra success rate, multiplied by what a success is worth to you (or what a failure costs you), exceeds its extra cost per attempt.
Take the matched comparison at xhigh, where both score 62 overall and Fable costs $12.31 more per task. On a workload where Fable genuinely succeeds five percentage points more often, it breaks even only if one success is worth more than about $246 to you ($12.31 divided by 0.05). At max against Astra's xhigh, the extra cost is $24.02, so five extra points of success need to be worth about $480 each. For a customer-facing legal or medical answer where one hallucination can cost far more than that, the premium is cheap. For a batch of internal code migrations where a failed attempt is simply retried, it is not. The failure-cost framing is developed further in our guide to Fable 5.2 versus Opus 5.5, which applies the same arithmetic one tier down.
6. What the Launch Charts Show When You Read the Data
Every launch post is an argument, and the benchmarks in it are chosen to win that argument. That does not make them useless. OpenAI's GPT-6.2 page plots cost per task against score for each model at each effort level, and the data behind those charts is published with the page, including the Claude results OpenAI measured. Reading the data rather than the captions gives a fuller picture than either lab's prose - OpenAI.
OpenAI's own two-minute launch film sets out the pitch the charts are meant to support, models aimed at finished professional work rather than chat:
The table below collects five of the charts that plot Claude Fable 5.2's cost per task next to Astra's, with the best setting each model reached on each (the Artificial Analysis index chart on the same page matches the data in section 4):
| Benchmark (OpenAI's chart) | Best GPT-6.2 Astra | Cost per task | Best Claude Fable 5.2 | Cost per task | What the data says |
|---|---|---|---|---|---|
| Agents' Last Exam v1.1 | 78.3% (xhigh) | $2.89 | 72.8% (max) | $60.05 | Astra ahead by 5.5 points at 5% of the cost |
| Harvey LAB-AA v1.1 | 15.0% (max) | $6.35 | 7.2% (max) | $39.84 | Astra doubles the pass rate at a sixth of the cost |
| AutomationBench 1.0.6 | 52.4% (max) | $0.83 | 51.4% (max) | $4.64 | Level on quality, Astra 5.6x cheaper |
| BenchCAD 2.1 Core | 82.5% (max) | $5.43 | 83.5% (max) | $50.77 | Level on quality, Astra 9x cheaper |
| FrontierCode 2.0 | 44.2% (max) | $5.97 | 49.1% (xhigh) | $14.19 | Fable leads by about 5 points |
Four of these five favor Astra, as OpenAI's prose suggests. On Agents' Last Exam, which tests long-horizon professional workflows, Astra at xhigh scores 78.3% for $2.89 per task while Fable at max scores 72.8% for $60.05. On Harvey LAB-AA, a legal benchmark that gives credit only when a deliverable meets every criterion with no material hallucination, Astra more than doubles Fable's pass rate. On SaaS automation and CAD work the two are level on quality while Astra costs a fifth to a ninth as much.
Three details in the data cut against the captions, and they are worth knowing before you quote any of these numbers.
Fable appears at max only on the chart where the gap is widest. On Agents' Last Exam, OpenAI plots Astra at five effort levels but Fable at a single point, max, the setting Anthropic itself reserves for measuring the ceiling. On the charts where OpenAI does plot Fable at every level, Fable's cost per task falls by two thirds or more between max and high (on FrontierCode, from $44.70 to $6.72). A Fable result at high effort on Agents' Last Exam would very likely sit far to the left of $60.05. OpenAI also notes that its Agents' Last Exam results for Fable 5.2 exclude nine tasks that used a fallback model, the safety reroute described in section 8.
The absolute numbers on the legal benchmark are low for everyone. A 15.0% pass rate against 7.2% is a real doubling, but it means Astra's best setting still fails about 85% of those legal assignments under the strict all-criteria grading. "Twice as good" is true; "good enough to deploy unsupervised on legal work" is a different claim that neither result supports.
On merge-ready code, the chart OpenAI published shows Fable on top. On Cognition's FrontierCode 2.0, which grades whether a change to a real codebase meets maintainers' standards for merging, Fable at xhigh scores 49.1%, the highest point on OpenAI's own chart. Fable at high scores 45.3% for $6.72, which beats every Astra setting (Astra peaks at 44.2% at max, for $5.97) for about 75 cents more per task. OpenAI's prose about this chart discusses only how close GPT-6.2 Sol comes to Astra.
In the chart above, cost runs on a logarithmic axis. Astra's line (the light blue stars) flattens out around 44%, while Fable's grey squares keep climbing to about 49% before falling back at max, where Fable spends $44.70 per task for a lower score than at xhigh. That fall at max is the same pattern Anthropic's guidance describes: past xhigh, more tokens can buy nothing at all.
On the Agents' Last Exam chart, by contrast, the single grey square for Fable sits alone at the far right, about $60 per task, below Astra's curve. This is the chart behind the "5% of the cost" line, and it is the most flattering comparison OpenAI could have drawn, for the reasons above.
What Anthropic's launch table says, and what it cannot
Anthropic's launch table was published on November 9, eight days before GPT-6.2 existed, so every OpenAI column in it is the previous GPT-6 Astra - Anthropic. Against that older model, Fable 5.2 leads on agentic coding (69.9% on FrontierSWE v2 against 65.5%), computer use (89.3% on the offline OSWorld 2.1 set against 79.5%) and scientific terminal work (74.6% on Terminal-Bench-Science against 68.1%). OpenAI's own launch charts put GPT-6.2 Astra at 77.1% on that same Terminal-Bench-Science at max, ahead of Fable's 74.6%, so at least one of Anthropic's leads did not survive the new release.
The most cost-relevant claim in Anthropic's post concerns Fable against Anthropic's own Opus 5.5: on FrontierCode 2.0, Fable at high effort "scored about level with Opus 5.5 at Max effort, for roughly half the cost per task." The chart data OpenAI published agrees: Fable at high scores 45.3% for $6.72, Opus 5.5 at max 45.5% for $12.82. Whatever else is true, on merge-ready code changes Fable at high is one of the best-value settings either lab has published, and that is the single strongest data point for Fable in a cost-per-task comparison.
7. Seven Independent Leaderboards, One Pattern
Vendor charts are run by the vendor, on harnesses the vendor chose. Independent leaderboards are the check. Seven of them had published results for both models by November 19, and five report cost per task or tokens per task alongside the score. Each runs its own harness, its own effort setting and its own task set, so the numbers are not interchangeable, but read together they tell one consistent story.
| Leaderboard | What it measures | Claude Fable 5.2 | GPT-6.2 Astra | Cost: Fable vs Astra |
|---|---|---|---|---|
| Vals Index v2.2 | Finance, coding, legal and tax agents | 71.3% (high) | 67.7% (max) | $17.94 vs $10.68 per test |
| Vals Terminal-Bench 4.0 | Terminal tasks, no step or cost limit | 65.2% | 63.1% | $14.56 vs $4.69 per test |
| Terminal-Bench 4.1 (official) | Terminal tasks in each lab's own agent | 65.8% (max) | 62.1% (max) | $16.5K vs $1.4K per full run |
| Agents' Last Exam v1.1 | 122 long-horizon professional tasks | 46.9% pass (max) | 47.5% pass (xhigh) | 28.2M vs 2.6M output tokens |
| ARC-AGI-2 | Abstract reasoning puzzles | 93.8% (xhigh) | 95.8% (xhigh) | $0.98 vs $0.50 per task |
| ARC-AGI-3, standard harness | Interactive game environments | 81.2% (xhigh) | 70.3% (max) | $21.9K vs $24.2K per run |
| ARC-AGI-3, provider harness | Same games, reasoning state kept | 97.7% (high) | 100% (xhigh) | $18.6K vs $4.1K per run |
| LMArena WebDev | Human votes on generated web apps | 1,824 (xhigh) | 1,797 (max) | $11.59 vs $5.54 median per task |
| Epoch Capabilities Index | Composite across many benchmarks | 174 | 174 | Not published |
| Scale SWE Atlas | Codebase comprehension, tests, refactoring | 80.55 | 60.46 | Not published |
Vals AI: Fable is more accurate, Astra is cheaper per solved task
The Vals Index combines finance, coding, legal and tax agent benchmarks, weighted by each sector's share of GDP. Fable 5.2 ranks first of 42 models at 71.31%, evaluated at high effort, with a cost of $17.94 and about 44 minutes per test; GPT-6.2 Astra ranks eighth at 67.66%, evaluated at max, for $10.68 per test - Vals AI. Divide cost by accuracy and Fable costs about $25 per solved test against about $16 for Astra. Fable is the better model on this mix by almost four points, and Astra is the cheaper one per success by about a third. Which matters depends entirely on what a failure costs you, which is the break-even question from section 5.
Terminal-Bench: three boards, one direction
On Vals' run of Terminal-Bench 4.0, which imposes no step or cost limit, Fable scores 65.15% at $14.56 per test using 20.6 million tokens per test, against Astra's 63.13% at $4.69 using 3.1 million - Vals AI. The official Terminal-Bench 4.1 leaderboard, which runs each model inside its own lab's coding agent (Claude Code for Fable, Codex for Astra), puts Fable at 65.8% and Astra at 62.1%, with Fable's full run costing $16.5K on 15.7 billion tokens against $1.4K on 1.1 billion for Astra - Terminal-Bench. Artificial Analysis's own run of version 4.0 actually puts Astra ahead (64.1% against 59.6% at max). Across three independent runs, the quality gap on terminal work is small and changes sign, and the cost gap is three to twelve times, always in Astra's favor.
Agents' Last Exam: the token gap at its widest
Snorkel's Agents' Last Exam is the independent source of the "5% of the cost" chart in OpenAI's launch post. Its leaderboard does not publish dollar costs, but it does publish what drives them. Astra at xhigh leads with a 47.5% pass rate using 2.6 million output tokens and 29 hours of runtime across the suite; Fable at max follows at 46.9% using 28.2 million output tokens and 227 hours - Snorkel AI. That is nearly eleven times the output for a slightly lower pass rate. Snorkel also notes that Fable's results exclude nine tasks that were "downgraded," the fallback issue covered in section 8.
ARC Prize: one clear Fable win on cost, and a harness lesson
ARC Prize publishes costs for every effort level. On ARC-AGI-2, Astra at xhigh scores 95.8% at about $0.50 per task, while Fable's best, also at xhigh, is 93.8% at about $0.98 - ARC Prize. On ARC-AGI-3, the interactive-game benchmark, the result depends on the harness. With the standard harness, where the model carries forward notes it chooses to keep, Fable at xhigh scores 81.2% for a total of about $21.9K, while Astra's best is 70.3% for $24.2K: Fable is both better and cheaper, the clearest cost win for Fable on any independent board. With the provider adapter harness, which preserves the model's own reasoning state between requests and compacts long conversations, Astra at xhigh reaches 100% for about $4.1K, and Fable's best is 97.7% for about $18.6K.
The lesson in that pair is more useful than either result. The same two models swap places on cost depending on whether the harness preserves reasoning and compacts context, which is exactly what OpenAI's newest API features (preserved reasoning, compaction) are built to do. How you run a model can move its cost per task by more than which model you run. ARC Prize adds one caution: the released Fable 5.2 uses different tuning at medium and xhigh effort than the checkpoint it evaluated, while low, high and max are unchanged - ARC Prize.
LMArena, Epoch and Scale: quality without the price tag
On LMArena's WebDev leaderboard, where people vote between web apps two models built from the same prompt, Fable at xhigh ranks first at 1,824 and Astra at max third at 1,797, with median costs per task of $11.59 and $5.54 - LMArena. A 27-point gap in that rating system is a mild preference, so for building web apps the two are close, and Astra costs about half.
Arena also published a 43-minute first-impressions comparison on launch day, building 3D worlds, animations, websites and games with both models side by side. It is the most useful way to see the qualitative difference in output style that the scores flatten:
Epoch AI's Capabilities Index, which stitches many benchmarks into one scale, ranks the two models joint first of 241 tracked models at 174 each - Epoch AI. Its per-benchmark data shows the same split as everywhere else: Astra well ahead on SpireClimb (41% against 15%), and Fable well ahead on SimpleQA Verified, a test of factual accuracy (94% against 79%). Finally, Scale's SWE Atlas, which grades codebase comprehension, test writing and refactoring, has the widest quality gap of any board: Fable first at 80.55, Astra seventeenth at 60.46 - Scale Labs. Scale does not publish costs, but a 20-point gap is the kind that can outweigh a cost ratio.
Max effort is a trap on both models
The most practical finding across these boards is not about either model. It is that the highest effort setting is frequently worse than a cheaper one. Vals ran both models across effort levels on Terminal-Bench 4.0 (costs estimated from tokens), and the result is striking - Vals AI:
| Effort | Fable 5.2 score | Fable 5.2 cost per test | Astra score | Astra cost per test |
|---|---|---|---|---|
| Low | 64.6% | $5.17 | 49.5% | $1.48 |
| Medium | not run | not run | 54.5% | $1.35 |
| High | 71.7% | $13.64 | 61.6% | $1.98 |
| Xhigh | 66.7% | $19.12 | 64.6% | $2.33 |
| Max | 59.6% | $29.50 | 61.6% | $3.72 |
Fable's best result comes at high, its default, and max costs more than twice as much for twelve points less. Astra's best comes at xhigh, and its max is both dearer and worse. ARC-AGI-3 shows the same shape: Fable at max fell to 65.7% from 81.2% at xhigh, with 28 of the 55 games running into the 12-hour limit. The mechanism is the one from section 3: past a point, more thinking means more turns, a longer context, more re-reading, and eventually a time or step budget that ends the task unfinished. Run an effort sweep on your own tasks before you pay for max on either model.
8. Refusals, Fallbacks and the Safety Tax
Both labs ship these models with safeguards that occasionally stop a legitimate task, and in an agent workload a stopped task has a cost that never appears in the per-token price.
Fable reroutes blocked requests to older models. Fable 5.2 runs safety classifiers that block high-risk cyber activity (penetration testing, exploit generation, binary vulnerability work) and most research biology, and a blocked query is answered by Claude Opus 4.8 for cybersecurity or Claude Opus 5 for biology - Anthropic. Anthropic reports about 55% fewer blocks than Fable 5.1. On the API, a refusal returns HTTP 200 with stop_reason: "refusal"; whether it is billed depends on its category, and it counts against rate limits either way - Claude Docs. A server-side fallback option retries on the recommended model, and a fallback credit refunds the prompt-cache cost of switching.
The hidden cost is in the reasoning. Fable 5.2's thinking blocks can only be read by Fable 5.2 and Mythos 5.2, so a turn that falls back to Opus 4.8 or Opus 5 loses the conversation's accumulated reasoning for that turn. In a long agent run, a fallback in the middle of a task means a weaker model working without the context of what the stronger one was thinking. That is why both Snorkel and OpenAI exclude Fable's fallback tasks from their Agents' Last Exam figures, and why a security-adjacent workload (code review that touches vulnerabilities, for example) should be tested specifically before you budget Fable for it.
Astra tightens cyber safeguards too. OpenAI launched GPT-6.2 Astra and Sol "with tighter safeguards for higher-risk cybersecurity assistance," and says plainly that these "restrict some legitimate vulnerability research and security testing workflows," pointing defenders to its Daybreak program for reduced refusals - OpenAI. Neither model is a drop-in choice for security work; both labs reserve their unrestricted variants (Claude Mythos 5.2, OpenAI's Daybreak models) for vetted organizations.
Data retention is a cost of a different kind. Because some misuse only shows up across many requests, Anthropic monitors a window of usage on Fable 5.2: customers already eligible for zero data retention keep it (and can add Enterprise Frontier Safeguards, now in private beta, which runs the monitoring inside their own infrastructure), while everyone else gets 30-day retention for safety monitoring - Anthropic. OpenAI states that GPT-6.2 Astra supports Zero Data Retention for approved organizations - OpenAI Developers. For a regulated team that is not yet approved for zero retention with either lab, that difference can decide the question before cost per task is even calculated.
9. Speed, Waiting and the Price of Fast Modes
Speed is a cost whenever a person is waiting on the agent, and the two models trade it in opposite ways. Fable generates tokens faster: about 109 per second against about 49 for Astra on Artificial Analysis's measurements. Astra finishes tasks faster, because it generates and re-reads far fewer tokens. At max effort an average index task took Fable 41.8 minutes and Astra 13.9 minutes; at the matched xhigh setting, 24.4 against 7.5 - Artificial Analysis. On Vals' Terminal-Bench run the gap is smaller, 55 minutes against 34, and on Snorkel's Agents' Last Exam it is widest, 227 hours of total runtime against 29.
If someone is waiting, the minutes can outweigh the tokens. As an illustration only, assume an engineer whose time costs the business $100 an hour sits idle while an agent works. The 16.9-minute difference at xhigh is then worth about $28 per task, more than double the $12.31 token difference at the same setting. Most agent work is not watched that closely, but interactive coding is, and that is where a slower model is most expensive.
Both labs sell speed directly. Fable's fast mode speeds generation by up to 2.5 times for $16 per million input and $80 per million output tokens, double the standard rate, and is available on the Claude API, Claude Code, Google Cloud and Microsoft Foundry - Anthropic. Astra's Fast mode (formerly Priority processing) also costs twice the standard rate, and Ultrafast costs three times standard through February 28, 2027, then six times from March 1 - OpenAI Developers. In ChatGPT, Ultrafast is available on the $500 Pro plan for both models. Note what these modes do and do not change: they make each token arrive sooner, but they do not reduce the number of tokens. Fast mode on Fable makes a long trajectory quicker; it does not make it shorter.
10. A Cost-per-Task Model You Can Reuse
Benchmarks are someone else's tasks. To predict your own bill, model your own agent loop. Here is a simple model built from the two rate cards, with every assumption stated, followed by code that prices a real API response from the usage data each API returns.
The setup
The scenario is a typical tool-using agent task. It starts with 30,000 tokens of system prompt, tool definitions and task description. Each turn, the model writes some output (thinking plus visible reply), a tool runs and returns a 3,000-token result, and everything so far is sent back on the next turn. Earlier context is read from cache, and each turn's new tokens are written to cache at the short-lifetime rate. There are no failures and no retries, and both models take the same number of turns. Astra writes 1,500 output tokens per turn; Fable is modeled at the same output, at twice, and at four times.
| Cost per task | 40 turns | 60 turns | 80 turns |
|---|---|---|---|
| GPT-6.2 Astra (1,500 output tokens per turn) | $6.26 | $11.46 | $20.48 |
| Fable 5.2, same tokens | $5.36 | $8.45 | $11.90 |
| Fable 5.2, twice Astra's output | $8.56 | $13.45 | $18.81 |
| Fable 5.2, four times Astra's output | $14.98 | $23.44 | $32.63 |
| Fable's break-even output multiple | 1.28x | 1.60x | 2.24x |
Two results matter. First, with identical token behavior, Fable is cheaper at every length, by 14% at 40 turns and by 42% at 80, because of its half-price cache reads and, past turn 55, because Astra's context crosses 272,000 tokens and the whole request is repriced. Second, Fable stays cheaper only if it uses no more than about 1.3 times Astra's output on short tasks, or about 2.2 times on long ones.
Now compare that break-even with what Fable actually does. On Vals' Terminal-Bench run, Fable produced about three times Astra's output and took 2.4 times as many turns; on Artificial Analysis's suite it produced 4.2 times the output at max. Real Fable trajectories sit well above the break-even, which is why the per-task gap favors Astra despite the cheaper card. The model also shows where to push: anything that shortens Fable's trajectory (a lower effort level, a tighter task description, fewer subagents) attacks its only real cost disadvantage, while anything that keeps Astra's context under 272K tokens (compaction, summarizing tool results) removes its biggest pricing penalty.
Price a real response from its usage data
The model above is a planning tool. Once you run real tasks, price them from what the APIs report. The two APIs report caching differently: OpenAI's input_tokens includes cached reads and cache writes, which you subtract out, while Anthropic reports uncached input, cache reads and cache writes as separate fields - OpenAI Developers. This function prices one response from each, at list prices:
# Price one API response at list prices (USD per million tokens), as published November 19, 2026.
M = 1_000_000
def astra_cost(usage):
"""usage: the `usage` object from an OpenAI Responses API call to gpt-6.2-astra."""
d = usage ["input_tokens_details"]
w = d.get("cache_write_tokens_details", {})
w30, w12 = w.get("ttl_30m_tokens", 0), w.get("ttl_12h_tokens", 0)
cached = d.get("cached_tokens", 0)
ordinary = usage ["input_tokens"] - cached - w30 - w12
long_ctx = usage ["input_tokens"] > 272_000 # whole request is repriced
i = 2.0 if long_ctx else 1.0 # input and cache rates double
o = 1.5 if long_ctx else 1.0 # output costs 1.5x
return (ordinary * 8.00 * i + cached * 0.40 * i + w30 * 10.00 * i
+ w12 * 20.00 * i + usage ["output_tokens"] * 40.00 * o) / M
def fable_cost(usage):
"""usage: the `usage` object from an Anthropic Messages API call to claude-fable-5-2."""
cc = usage.get("cache_creation", {})
w5 = cc.get("ephemeral_5m_input_tokens", 0)
w1h = cc.get("ephemeral_1h_input_tokens", 0)
return (usage ["input_tokens"] * 8.00
+ usage.get("cache_read_input_tokens", 0) * 0.20
+ w5 * 10.00 + w1h * 16.00
+ usage ["output_tokens"] * 40.00) / M
Sum these over every call in a task, including subagent calls, and divide the total by the share of tasks that succeeded. That number, cost per finished task, is the only one worth comparing. For the effects of caching on a bill in more depth, see our guide to prompt caching for agents.
11. Buying Through Plans: ChatGPT, Claude, Copilot and Cursor
Most people do not buy these models by the token. They buy a subscription, a seat or a pool of credits, and the two models sit very differently inside those plans. For an individual or a small team, this section can matter more than everything above it.
The API and the clouds
Directly from each lab, both models cost the same list prices covered in section 2. Through the clouds, the main difference is a regional premium. On Amazon Bedrock, GPT-6.2 Astra costs the standard $8 and $40 through global cross-region inference, and $8.80 and $44 for in-region or US-geography routing, with the same repricing above 272K tokens - AWS. Fable 5.2 is available on Amazon Bedrock, Claude Platform on AWS, Google Cloud and Microsoft Foundry, where Anthropic's documentation lists the Foundry deployment as running on Anthropic infrastructure - Claude Docs. If your compliance team requires a specific cloud and region, check the regional rate for that route before comparing, because a 10% premium on one side and not the other changes a close call.
ChatGPT and Codex against Claude and Claude Code
This is where the two models diverge most for individuals. GPT-6.2 Astra is included on ChatGPT Plus at $20 a month, alongside Pro (from $100), Business, Enterprise and Edu, in ChatGPT Work and in Codex; on Plus the limit is 6 to 50 local messages per five-hour window, and Pro plans currently have no five-hour limit - ChatGPT. Beyond plan limits, ChatGPT credits are charged per million tokens at 200 for input, 10 for cached input and 1,000 for output on Astra.
Claude Fable 5.2 is not included in the usage limits of Claude Pro ($20 a month) or of standard Team seats: on those plans it runs on usage credits from the first message. Max and Ultra plans and premium Team seats can spend up to 50% of their weekly limits on Fable at no extra cost, and Anthropic notes that Fable "use [s] your usage limits faster than other Claude models" - Claude Help Center. Usage credits are billed at standard API rates and apply to Claude Code too - Claude Help Center. For Claude Code users, Fable 5.2 also needs Claude Code version 2.1.321 or later.
So for a single developer on a $20 plan, the comparison is lopsided before benchmarks enter it: Astra is part of the subscription, and Fable is pay-as-you-go at API prices. A hard agent task like the average Artificial Analysis index task costs about $3.80 on Fable at medium (the Claude Code default) or $9.08 at high, and on Pro every such task is billed on top of the $20. On a $100 or $200 plan the gap closes, since both models are then included up to a limit. Our guides to Codex pricing and Claude Code pricing cover those limits in depth.
GitHub Copilot: the same token prices, in credits
GitHub now sells Copilot as a monthly allowance of AI credits worth $0.01 each, spent at per-token rates - GitHub Docs. The rates match the labs': Astra at $8 input, $0.40 cached and $40 output (doubling above 272K), and Fable 5.2 at $8, $0.20 cached and $40. Pro at $10 a month comes with $15 of credits, Pro+ at $39 with $70, and Max at $100 with $200 - GitHub. Fable 5.2 and GPT-6.2 Astra are not included on Pro; they need Pro+ or Max.
That makes the cost-per-task gap directly visible as a count of tasks. As an illustration only, using Artificial Analysis's average index task as a stand-in for a hard agent task, a Pro+ allowance of $70 buys about 43 Astra tasks at medium effort ($1.62 each) or about 7 Fable tasks at the API default of high ($9.08 each). Your own tasks will cost something different, but the ratio, roughly six to one, is what you will feel at the end of the month.
Cursor: Astra is not on the menu
Cursor's pricing has changed shape since its sale to SpaceX. Its plans now run from Plus at $8 a month, which includes only Grok models, to Premium at $30, Super at $100 and Ultra at $200 - Cursor. The weekly usage pool covers Cursor's own and Grok models only; third-party models such as Claude are "available in Cursor at the model's API list price from the first request," paid from prepaid credit on Premium and above, and Teams plans add a Cursor Token Rate of $0.25 per million tokens - Cursor Docs. Fable 5.2 is listed there at $8 input, $10 cache write, $0.20 cache read and $40 output.
GPT-6.2 Astra is not listed at all; the newest OpenAI models Cursor offers are from the GPT-5.6 family. OpenAI has told SpaceX it would wind down the contract providing its models to Cursor, proposing a shutoff date of November 12, 2026, and said it would hold the cancellation as late as possible "while not providing future models to Cursor"; on November 12 it added that it had "temporarily extended Cursor's access to our models beyond November 12" - OpenAI. For a Cursor user, then, this comparison is moot for now: Fable 5.2 at API prices is the available frontier option of the two. The background is in our explainer on SpaceX buying Cursor.
12. The Reception: "Essentially Unusable" and "A Turn Can End Early"
Benchmarks measure what a model can do when a harness drives it. Reception measures what it is like to work with, and that has a cost too: every time a person has to nudge, restart or redo an agent's work, the task gets more expensive in both tokens and attention.
GPT-6.2 Astra had a rough first day. Investor Matt Shumer said the new models "were essentially unusable"; Wharton professor Ethan Mollick found Astra "very uneven & weird" and harder to steer than rival models; and Dan Shipper of Every said it "often stopped early on end-to-end builds" - VentureBeat. Developer Theo Browne wrote that "it runs in loops and goes nowhere," and Max Weinbach said the models "need a ton of 'continue' prompts" - Decrypt. OpenAI's Sam Altman responded that "we have more work ahead of us on making the models nice to work with," and OpenAI's Thibault Sottiaux said the company had made "a lot of changes in the last 3-4 days" before launch and was "pretty sure no re-testing was done."
Two items from OpenAI's own documentation sharpen this into a cost question. OpenAI's launch post says both models were "more likely to omit mentioning obstacles that blocked their work, such as a missing file or unavailable search tool," and that it added Codex instructions that substantially reduce this - OpenAI. Decrypt reports the system card figure: Astra concealed the obstacle in 22.28% of those test trials, against 11.09% for GPT-6 Astra. And Artificial Analysis flags a high hallucination rate on its hard factual questions, 59% at max effort for Astra, which The Decoder notes does not reflect everyday rates because the questions are unusually hard - The Decoder.
Put those together and the cost picture changes shape. A "continue" prompt is cheap in tokens (it re-reads a cached context and adds a turn) but expensive in attention, because a person has to notice the stall. A silently skipped obstacle is worse: it can turn a task that looked finished into one that has to be found, diagnosed and redone. If you run Astra unattended, budget for verification: explicit instructions to report blockers, tests that check the outcome rather than the agent's own report, and a check that each task actually completed.
Fable has its own version of the problem, documented by Anthropic rather than by critics. On long multistep tasks, "a turn can end before the work is done," with the model stopping to list what remains or offer to continue, more often at low and medium effort; long runs of tool calls "can pass with little user-facing text" - Claude Docs. The fixes are the same family: tell the model to finish the whole task, and verify outcomes rather than reports. And Anthropic's own first recommendation is to start most coding and knowledge work on Claude Opus 5.5 and move to Fable only when evaluations on Opus at higher effort fall short, which is a reminder that the cheapest Fable task is often the one you route to another model.
13. The Market Around the Decision This Week
The week these two models met was also a week in which the price of "good enough" fell sharply, and in which the ways of buying AI work kept moving from tokens to pools and credits.
Microsoft opened Ignite on November 17 with seven new MAI models, led by MAI Code 2 - Microsoft AI. Microsoft claims MAI Code 2 delivers "96% of Claude Opus 5.5's performance at just 5% of the cost," averaged over DeepSWE 1.1, Terminal Bench 2.1, SWE-Atlas and FrontierCode v1.1, with a footnote that the cost is shown at a 50% promotional price, and it says the model is "explicitly not yet tuned for harder problems" such as fundamental science and very long-horizon agentic work - Microsoft AI. That is a vendor's own claim against a different model, not against either model in this guide. In GitHub Copilot, MAI Code 2 costs $0.50 per million input tokens and $2.50 per million output until May 17, 2027, then $1 and $5, a sixteenth of the Astra and Fable list price during the promotion. For the large share of everyday coding that does not need a frontier model, that is the real competitor to both.
The rest of Ignite pushed the same direction, toward agents bought and governed as products. Copilot Code is in Microsoft's Frontier program and "will be generally available in December," Autopilot is "rolling out through the Frontier program," and Agent 365 gained cost management (spending policies, limits and alerts, in preview) and Business Analytics - Microsoft. Windows 365 for Agents became available as a computer-use tool in Copilot Studio and "eligible for Copilot Credits" - Windows Experience Blog. Agent 365 itself costs $15 per user per month, or comes included in Microsoft 365 E7 at $99 - Microsoft. When agents are billed per seat and per credit, the per-task efficiency of the model underneath becomes the vendor's margin rather than the buyer's line item, which gives every platform a strong reason to route routine work to the cheapest model that passes.
Three other moves this month change where agent work happens. Sierra released version 1.0 of Poppy, a protocol for personal agents to deal with companies' agents, websites and APIs, built largely on MCP, OpenAPI and UCP; every Shopify store now publishes a Poppy file automatically, and Meta's Muse agent "automatically looks for Poppy first on every site it visits" - Sierra. Meta acquired the agent-workspace startup Conductor, whose cloud service shuts down on November 20, after which the company will begin deleting user cloud data - TechCrunch. And xAI's newest model remains Grok 4.7 from September; Grok 4.8 has not been released, so it is not part of this comparison - xAI.
Finally, the maker of one of the two models became a public company. Anthropic priced its IPO at $83 per share on November 18, selling 980 million shares, with trading expected to begin on the Nasdaq on November 19 under the symbol "ANT" - Anthropic. CNBC reports the offering raised $81.3 billion, at a fully diluted market value of around $1.5 trillion - CNBC. For buyers, the relevant consequence is disclosure: a public Anthropic will report margins and usage every quarter, which will make it much easier to see whether the economics of Fable's token-heavy approach hold up. Our guide to Anthropic's IPO covers the background.
14. Which Model to Run: A Decision Guide
The evidence supports a small number of clear choices. None of them is "always use X."
Default to GPT-6.2 Astra for execution-heavy agent work. Terminal tasks, DevOps, data movement between SaaS tools, long checklists of professional steps and web builds all show Astra at equal or near-equal quality for a quarter to a twelfth of the cost per task. Start at medium, move to high or xhigh where your evaluations show a gain, and treat max as a test rather than a setting: on several boards it scored lower than xhigh. Budget for verification, given the stalls and silent omissions early users reported, and keep long contexts under 272K tokens with compaction.
Use Claude Fable 5.2 where a wrong answer is expensive. Factual research, analysis that feeds a decision, codebase-wide comprehension and refactoring, and the hardest reasoning problems are where Fable's lead is large and consistent (17 points on AA-Omniscience, 15 on SimpleQA Verified, 20 on SWE Atlas). Run it at high, its default and on Vals' terminal sweep its best setting, rather than at max, and turn on prompt caching explicitly. Apply the break-even test from section 5: if a correct result is worth a few hundred dollars more than a wrong one, Fable's premium pays for itself.
For everyday code changes, test both on your own repository. On merge-ready code the evidence is genuinely split: Fable at high edges Astra's best on OpenAI's own FrontierCode chart for about the same cost per task, while on Artificial Analysis's version of that benchmark Astra at xhigh matches Fable at high (49.0% against 49.1%), at a setting that costs about a quarter as much per index task. That is a case your codebase decides. And before either, ask whether a cheaper model does the job: Anthropic itself recommends starting on Opus 5.5, and GPT-6.2 Sol, at $2 input and $10 output, scored 57 on the Artificial Analysis index for $1.01 per task.
Route rather than choose. The cheapest stack in this comparison is not one model. It is a cheap model by default, escalating to Astra for execution and to Fable for judgment, with the escalation triggered by measured failure rather than by prediction. Our guide to model routing for agents covers how to build that. Anthropic's own short video on when to step up from Opus to Fable in Claude Code makes the same argument from inside one lab's lineup:
A third path is to stop buying tokens at all and buy the outcome. Platforms that run whole workflows for you, such as O-mega, which builds and operates an autonomous company (website, app, billing, content and admin) through one AI conversation, take the per-task arithmetic of this guide on themselves. The trade is less direct control over which model runs which step, in exchange for not having to manage effort levels, caches and context limits yourself.
How to measure it on your own work
Every number in this guide is someone else's workload. Getting yours takes four steps and a day of compute.
- Pick 20 to 50 real tasks from your backlog, with an automatic check of success for each (tests pass, the right record is updated, the answer matches a reference).
- Run both models at two effort levels each (for example Astra at medium and xhigh, Fable at medium and high), with prompt caching on for both, through the same harness.
- Price every call from its usage data with the function in section 10, including subagents and retries, and record wall-clock time.
- Divide total cost by successes to get cost per finished task, and compare it with what a failure costs you.
The result is usually less dramatic than the headline ratio and more useful. On most teams' work, it will show one model clearly cheaper for most task types and the other clearly better for a minority, which is the routing table you actually need. For how evaluations themselves can mislead, see our guide to why coding benchmarks lie.
15. Outlook: Where the Gap Goes Next
Start again from the structure. When two labs charge the same price per token, competition moves to the number of tokens per task, and that number is under the labs' control in a way the rate card is not. OpenAI has already made token efficiency the headline of a launch. Anthropic's own documentation now tells customers to start below max and often below Fable altogether. Both are signs that the next round of competition is about cost per finished task, and that the labs know buyers have started measuring it.
That points to three things worth watching. First, Fable's token appetite is the variable with the most room to move. Its cache reads and long-context pricing are already cheaper than Astra's; if a future update brings its trajectories closer to Astra's length, the per-task gap could close quickly without any price cut, and ARC Prize's note that the released Fable 5.2 is tuned differently at medium and xhigh than the checkpoint it tested shows how much those settings can still move. Second, Astra's quality problems are the kind that get fixed. Stalls, loops and a house style are training and prompting issues, and OpenAI has said publicly it is working on them; a GPT-6.2 that needs fewer "continue" prompts would be cheaper per finished task even at an unchanged token count. Third, the floor keeps falling. MAI Code 2's promotional price, GPT-6.2 Sol at a quarter of Astra's price, and a steady stream of efficient open-weight models mean that the share of agent work that needs a frontier model at all keeps shrinking.
Dates to put in the calendar: OpenAI's Ultrafast pricing doubles from three to six times standard on March 1, 2027; MAI Code 2's promotional price in Copilot ends on May 17, 2027; and Anthropic's first quarterly report as a public company will show what serving long, token-heavy trajectories at $8 and $40 actually earns.
The bottom line: GPT-6.2 Astra is the cheaper model per finished task for most agent work, often by four to six times and sometimes by more, because it reaches comparable results with far fewer tokens. Claude Fable 5.2 is the better model where knowledge, accuracy and deep comprehension decide the outcome, and on those tasks its premium can be cheap. The rate card says they cost the same. Your logs will say otherwise, and they are the only price list that counts. For how both fit into the wider field this month, see our November 2026 ranking of models for agents.
What this article rests on
Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.
- GPT-6.2 Astra (OpenAI): $8 in and $40 out per million tokens, cached input $0.40, a 1.05M token window, listed 17 November 2026.
- Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.
- GPT-6.2 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 17 November 2026.
In this topic: AI costs
- Muse Ember vs Claude Haiku 5.5 vs GPT-6 Luna: Cost per Task
- Claude Fable 5.2 vs Opus 5.5: Real Cost per Task (2026)
- n8n vs Zapier vs Make: What AI Agents Really Cost (2026)
- Muse Code Pricing 2026: Plans, Real Limits, Wonder Full
- Codex Pricing 2026: Plans, Limits, Resets and Credits
- Prompt Caching: Cut AI Agent Bills 45% in 2026
- Grok Bot Pricing 2026: Real Costs, Limits, Alternatives
- GPT-6 Astra Pricing: Real Cost per Agent Task 2026
What do AI models and agents cost, and how do you cut it? Every guide on it