Since this was written, OpenRouter's model feed lists GPT-5.4 Mini in place of gpt-5-mini; GPT-5.4 Nano in place of gpt-5-nano.
Same $8 and $40 per million tokens, eight days apart. Measured per finished task, the two flagships are nowhere near the same price, and which one is cheaper flips with the kind of work you hand them.
On November 9, 2026, Anthropic released Claude Fable 5.2 at $8 per million input tokens and $40 per million output tokens - Anthropic. Eight days later OpenAI answered with GPT-6.2 Astra at exactly the same list price, $8 and $40, a 20% cut from GPT-6 Astra - OpenAI. Both accept roughly a million tokens of context, both write up to 128,000 tokens in one response, and both sell a fast mode at twice the standard rate. On a price sheet, "Fable 5.2 vs GPT-6.2 Astra" looks like a tie that only benchmarks can break.
It is not a tie, and the benchmarks do not break it the way launch-week headlines suggested. On the Artificial Analysis Intelligence Index, Fable 5.2 at its maximum effort scores 65 against Astra's 62, but it costs $26.54 per task against Astra's $4.00 - Artificial Analysis. At matched scores the gap is still wide: Astra reaches 62 at its xhigh setting for $2.52 a task, while Fable needs its high setting and $9.08. Then you move to real coding agents and the order reverses. Fable 5.2 at high effort inside Claude Code scores 58.2 on the Coding Agent Index for $7.51 a task, while Astra's best run inside Codex scores 53.5 for $5.12, and Fable at medium effort comes within half a point of Astra's best for 56% of its cost - Artificial Analysis Coding Agent Index.
The fine print diverges as well. Fable's cached input costs half of Astra's, Fable bills its whole context window at one rate, and Astra doubles its input price and raises its output price by half on any request longer than 272,000 tokens - OpenAI model docs. Fable requires 30-day data retention; Astra can run under zero data retention for approved customers. The two labs even disagree about where you should start: OpenAI tells developers to begin with Astra for most reasoning work, while Anthropic tells them to begin one tier lower and climb to Fable only when their evaluations demand it.
So the useful question is not which model is better. It is which model turns your particular mix of work into finished results at the lowest cost and risk, and how to build so that the answer can change next month without a rewrite. This guide works through that question from first principles: what each lab shipped, both price structures line by line, what each lab claims and how it chose its opponents, what independent testers measured, cost per task worked out from the token arithmetic, coding agents versus knowledge work, speed, context and caching, the API changes that break code on each side, refusals and failure reporting, data and platform constraints, who pays the bill, the field around both models, the deadline calendar through December, and a routing architecture that uses each model where it wins.
This guide reflects both models, their prices and the independent results as of November 22, 2026. Independent leaderboards are rerun as test suites are versioned and both labs reprice often, so check the linked pages before you commit a budget.
Contents
- The Short Answer: Which to Build On
- What Shipped on November 9 and November 17
- One Rate Card, Two Price Structures
- What Each Lab Claims, and How It Picked Its Opponents
- What Independent Testers Measured
- Cost per Finished Task, Worked Out From First Principles
- Coding Agents: Where Fable 5.2 Pulls Ahead
- Documents, Science and 3D: Where Astra Pulls Ahead
- Speed, Effort and Latency
- Context Windows, Caching and Long Sessions
- Building on Each API: Breaking Changes and Agent Plumbing
- Reliability: Refusals, Fallbacks and Honest Failure Reports
- Data, Platforms, Rate Limits and Who Pays the Bill
- The Field Around Them and the Next Six Weeks
- A Routing Architecture That Uses Both
- Verdict and Decision Checklist
1. The Short Answer: Which to Build On
If you read one section, read this one, then check the evidence behind each line in the sections that follow.
For long-horizon coding agents, build on Fable 5.2, and run it at high effort rather than max. It leads every independent coding-agent measurement that tests both models, and at medium effort it already comes within half a point of Astra's best coding score for less money. The trap is the top setting: on the Coding Agent Index, Fable at max scores lower than at high (55.7 against 58.2) and costs almost six times as much per task ($44.22 against $7.51) - Artificial Analysis. Most of the stories about Fable's eye-watering bills come from max-effort runs.
For knowledge-work deliverables at volume, build on Astra. Documents, spreadsheets, slide decks, legal research, computational science in a terminal and interactive 3D are where OpenAI aimed this release, and the independent results back the token-efficiency claim: across the whole Artificial Analysis suite, Astra spends roughly a quarter of the output tokens Fable spends at the same effort label. When the task is well specified and the deliverable is a document, Astra finishes it for a fraction of Fable's cost.
If single requests regularly exceed 272,000 tokens, Fable's flat pricing wins by default. Astra bills such requests at $16 input and $60 output per million, with cached input at $0.80 instead of $0.40. Fable charges the same $8 and $40 at 900,000 tokens as at 9,000, which Anthropic states in exactly those terms - Anthropic pricing.
If your contracts forbid retention of prompts, check Fable's terms before anything else. Fable 5.2 requires 30-day data retention and is not available under zero data retention unless Anthropic expressly authorizes it, while OpenAI offers zero data retention to approved customers on its eligible endpoints.
For most production traffic, build on neither. Anthropic itself recommends starting with Claude Opus 5.5 at $4 and $20, and OpenAI's own GPT-6.2 Sol at $2 and $10 comes within half a point of Astra on one coding benchmark at about a fifth of the cost. A frontier flagship earns its price on the hard tail of your workload, not on every request.
Whatever you pick, build so the choice is cheap to reverse. The two labs priced their flagships eight days apart at the same number, and a third lab's model took first place on the coding-agent index the day after the second launch. A model decision you cannot undo in an afternoon is a bet on the next release cycle.
The table below sets out the facts that decide most builds. Every figure is sourced in the sections that follow.
| Claude Fable 5.2 | GPT-6.2 Astra | |
|---|---|---|
| Released | November 9, 2026 | November 17, 2026 |
| Price per 1M tokens (in / out) | $8 / $40 | $8 / $40 |
| Cached input per 1M | $0.20 | $0.40 |
| Long requests | Same rate to the full 1M window | Over 272K input: input and cache 2x, output 1.5x |
| Context window / max output | 1M / 128K | 1.05M (922K max input) / 128K |
| Effort levels (default) | low, medium, high, xhigh, max | low, medium, high, xhigh, max (no none) |
| AA Intelligence Index (max) | 65, $26.54 per task | 62, $4.00 per task |
| AA Coding Agent Index (best) | 58.5 at xhigh, 58.2 at high ($7.51) | 53.5 at max ($5.12) |
| Vals Index | 71.31%, ranked first | 67.66%, ranked eighth |
| Output speed (AA) | about 108 tokens per second | about 46 tokens per second |
| Fast mode | $16 / $80, up to 2.5x output speed | $16 / $80; Ultrafast at 3x until Feb 28, 2027 |
| Data retention | 30 days required; no ZDR unless authorized | ZDR available to approved customers |
| Knowledge cutoff | June 2026 | May 18, 2026 |
| Earliest retirement | Not before November 9, 2027 | Not announced |
2. What Shipped on November 9 and November 17
Claude Fable 5.2: Anthropic's top tier, cheaper and faster
Fable 5.2 is one of two names for the same model. "Claude Fable and Claude Mythos are the same underlying model," Anthropic's launch post says: Fable carries cybersecurity and biology safeguards that let Anthropic open it to every customer, while Mythos 5.2 is reserved for organizations that pass its verification programs - Anthropic. The release cut the price from Fable 5.1's $10 and $50 to $8 and $40, generates output up to 30% faster than the previous version, and adds a fast mode that speeds generation by up to 2.5 times at $16 and $80 per million tokens.
The developer documentation fills in the shape of the model. It has a 1 million token context window that is both the default and the maximum, 128,000 output tokens per request, and adaptive thinking that is always on, with depth controlled by five effort levels from low to max and an API default of high - Anthropic docs. Its reliable knowledge cutoff is June 2026, and Anthropic commits not to retire it before November 9, 2027 - Anthropic models overview.
The launch post spent as much space on demonstrations as on benchmarks, and two of them matter for builders because they show the kind of work the model is tuned for. One Anthropic engineer gave Fable 5.2 an empty folder and the task of designing a prototype operating system; the model coordinated more than 1,000 subagents for eight days and produced a system that boots on a laptop with its own drivers, file storage, windows, login screen and installer. Separately, a team of 1,000 Fable 5.2 agents formalized the proof of Fermat's Last Theorem in 30 hours, where Anthropic's first formalization with an unreleased research model took 11 days. Both are examples of very long, highly parallel, loosely specified work, which is exactly where the independent coding results in Section 7 also place Fable's advantage.
The most important sentence in the launch post for anyone choosing a model is a recommendation against using it by default. "For most coding and knowledge tasks, we recommend that users start with Claude Opus 5.5, our strongest daily driver," Anthropic writes, and then switch upward to Fable or downward to Sonnet 5.5 or Haiku 5.5 as the work requires. The models overview repeats the advice: use Fable "when your evals on Claude Opus 5.5 at higher effort still fall short."
GPT-6.2 Astra: OpenAI's flagship, aimed at professional output
OpenAI launched two models on November 17: Astra, "our new frontier model for your hardest projects," and GPT-6.2 Sol, its "efficient, versatile model for everyday work" - OpenAI. Both went live the same day in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users and in the API as gpt-6.2-astra and gpt-6.2-sol. The pitch was not raw intelligence but efficiency: both models "deliver better results on demanding tasks with fewer output tokens," and Astra's slides, spreadsheets and documents are meant to "read less like AI" and follow the templates and conventions of the reader's field.
The API page lists a 1,050,000 token context window with a 922,000 token maximum input, 128,000 output tokens, text and image input, a knowledge cutoff of May 18, 2026, and reasoning that cannot be switched off: the API rejects requests that set reasoning effort to none - OpenAI model docs. In the Responses API, Astra can delegate to subagents in a beta multi-agent mode and use OpenAI's hosted tools, including web and file search, code interpreter, a hosted shell, apply patch, skills, computer use, MCP and tool search.
OpenAI's own guidance points the opposite way from Anthropic's. Its reasoning guide opens with "Start with gpt-6.2-astra for most reasoning workloads," and suggests GPT-6.1 Terra or GPT-6 Luna only when cost or latency come first - OpenAI reasoning guide. That asymmetry is structural rather than cosmetic. OpenAI positions Astra as the default top of its line, priced to be used broadly, while Anthropic positions Fable as a specialist tier above a default model that costs half as much. For many Anthropic-centred builders, the honest comparison is therefore Astra against Opus 5.5 for everyday work and Astra against Fable only for the hardest tail.
OpenAI's two-minute launch film walks through the professional-output examples it leads with: workbooks, slide decks, CAD and interactive 3D.
Watch it with Section 8 in mind: nearly every example is a deliverable a person would read or use (a valuation workbook, a deck, a simulation), not a codebase an agent maintains for days. That is the shape of work on which the independent results favour Astra, and the film is an honest map of where OpenAI expects the model to earn its price.
Eight days that reset the top of the market
The two launches did not happen in isolation. Google completed its Gemini 4 line on the same timetable: Gemini 4 Carbon went generally available on November 10 at an introductory $2 and $10, Gemini 4 Hydrogen on November 12 at $1.50 and $7.50 as the only one on the free tier, and Gemini 4 Neon on November 18 at $3 and $15 - Gemini API changelog. Neon then claimed first place on the same Coding Agent Index that this guide relies on, which Section 14 covers. On the money side, Anthropic put linked billing into beta on November 17, letting an app's customers pay for its Claude usage from their own Claude organization - Claude. It priced its initial public offering at $83 a share the next day, as Section 13 details. For the Google side of the comparison, our guide to Fable 5.2 against Gemini 4 Carbon works through that pairing in the same depth.
3. One Rate Card, Two Price Structures
Both labs publish the same two headline numbers, and almost everything else on their price pages differs. Because an agent's bill is dominated by cached context and long requests rather than by the headline input rate, the differences below decide real costs more often than the headline does.
| Rate per 1M tokens | Claude Fable 5.2 | GPT-6.2 Astra |
|---|---|---|
| Standard input / output | $8 / $40 | $8 / $40 |
| Cached input (reads) | $0.20 (0.025x input) | $0.40 (0.05x input) |
| Cache writes | $10 for 5 minutes, $16 for 1 hour | $10 for 30 minutes, $20 for 12 hours |
| Requests over 272K input tokens | No change | Input and cache rates double, output 1.5x, for the whole request |
| Batch (in / out) | $4 / $20 | $4 / $20 |
| Asynchronous background windows | None | 30% off for a 2-hour window, 40% off for 8 hours |
| Fast mode (in / out) | $16 / $80 | $16 / $80 |
| Fastest tier | Fast mode is the top speed | Ultrafast at $24 / $120 until Feb 28, 2027, then $48 / $240 |
| Regional or US-only processing | 1.1x for US-only inference | 10% uplift for regional processing |
The sources for the table are Anthropic's pricing page and OpenAI's pricing page - OpenAI pricing.
Cache reads: where Fable is cheaper
For an agent, the cache-read rate is often the most important number on the page. Every turn of an agent loop resends the system prompt, the tool definitions and the conversation so far, and with caching most of that is billed as a cache read rather than fresh input. Anthropic prices Fable's cache hits at 0.025 times the base input price, which works out to $0.20 per million - Anthropic pricing. OpenAI cut Astra's cached input by 60% from GPT-6 Astra's $1.00 to $0.40, a real improvement that still leaves it at twice Fable's rate - OpenAI.
The two labs also price cache writes differently in a way that rewards different traffic shapes. Fable's short cache lives for five minutes and costs $10 per million to write, with a one-hour cache at $16; Astra's standard cache lives for 30 minutes at the same $10, with a 12-hour option at $20 - OpenAI model docs. A chat product whose users pause for ten or twenty minutes between messages keeps a warm cache on Astra's default retention and loses it on Fable's, unless it pays for the hour. A tight agent loop that fires a request every few seconds never notices the difference. Our guide to prompt caching covers the mechanics of choosing a retention window.
The 272K line: where Astra changes price
The single largest structural difference is OpenAI's long-context rule. "For requests with more than 272K input tokens, input and cache rates double and output costs 1.5 times the short-context rate for the full request," the Astra model page says - OpenAI model docs. A request with 300,000 input tokens is therefore billed at $16 input, $0.80 cached input and $60 output for every token in it, not only for the part above the line. Anthropic takes the opposite position for all its current models except Haiku 5.5: the full 1 million token window at standard pricing, so a 900,000 token request pays the same per-token rate as a 9,000 token request - Anthropic pricing.
The practical consequence is that the two price cards are identical only below 272,000 tokens per request. Codebase-wide refactors, agents that accumulate long tool histories, legal or financial work over large document sets and any design that leans on the million-token window instead of retrieval will cross that line, and on Astra each crossing changes the price of the whole call. Section 6 works through what that does to a real session.
Discounts that exist on only one side
Both labs offer the Batch API at half price, and that is where the symmetry ends. OpenAI adds discounted background windows on the Responses API: eligible requests that can wait two hours cost 30% less than standard, and those that can wait eight hours cost 40% less - OpenAI pricing. That gives Astra a middle ground between interactive and overnight batch that Fable lacks. In the other direction, Anthropic's prompt caching multipliers stack on top of its batch discount, so a cached read inside a Fable batch job costs $0.10 per million tokens.
Speed tiers: same fast price, different top speed
Both fast modes cost exactly twice the standard rate, $16 and $80. Anthropic's fast mode offers up to 2.5 times higher output tokens per second on Fable 5.2, applies across the full context window and cannot be combined with the Batch API - Anthropic pricing. OpenAI goes one tier further with Ultrafast, which supports GPT-6.2 Astra and Sol and costs three times the standard rate through February 28, 2027 and six times from March 1, 2027 - OpenAI Ultrafast guide. Anyone building a latency-sensitive product on Ultrafast is building on a price that doubles in three months, and should model it that way now.
4. What Each Lab Claims, and How It Picked Its Opponents
Launch tables are marketing documents written by people who choose which tests to run and which rivals to include. Reading them well means noticing the choices, not only the numbers.
Anthropic compared Fable 5.2 with the previous Astra
Anthropic's table puts Fable 5.2 against Fable 5.1, Opus 5.5, GPT-6 Astra and Gemini 4 Carbon. Its headline coding figure is 49.1% on Cognition's FrontierCode 2.0 at xhigh effort, against 45.5% for Opus 5.5, 42.8% for GPT-6 Astra and 41.1% for Carbon, and it reports 69.9% on FrontierSWE v2, 89.3% on OSWorld 2.1 computer use, 41.3% on the Remote Labor Index and 74.2% on Humanity's Last Exam with tools against 57.2% for GPT-6 Astra - Anthropic. The rival in that table is GPT-6 Astra from September, because GPT-6.2 Astra did not exist on November 9. Every Anthropic comparison against "Astra" therefore understates the current OpenAI model, and none of them should be read as a head-to-head with the model this guide is about.
Two of Anthropic's own results are worth keeping because they cut against the simple story. On AutomationBench, a test of business workflows, Fable 5.2 scored 51.4% and Gemini 4 Carbon scored higher at 53.9%. And Anthropic's effort chart for FrontierCode notes that at high effort Fable scored 45.3%, essentially level with Opus 5.5's best at roughly half the cost per task, which is the clearest statement in the launch post that the effort setting matters as much as the model.
OpenAI compared Astra 6.2 with Fable 5.2, on its own harnesses
OpenAI had the advantage of launching second, and it ran Fable 5.2 on several of its charts. On Agents' Last Exam, a test of long-horizon professional workflows, it reports Astra 5.5 points ahead of Fable 5.2 "at just 5% of the cost," with a footnote that matters: "Its leaderboard results for Fable 5.2 exclude nine tasks that used a fallback model" - OpenAI. On Harvey's LAB-AA legal benchmark it claims more than double Fable's pass rate at about a sixth of the cost, and on Artificial Analysis's blinded AA-3D preference test it reports an Elo of 1,318 for Astra against 1,271 for Fable and 1,259 for GPT-6.2 Sol.
Those are real results, and they are also the results a lab chooses to publish. OpenAI's strongest charts are on professional deliverables, legal work and 3D, where Section 8 shows the independent data agrees with it. Its launch post does not show Astra against Fable on the agentic coding indexes, where Section 7 shows the independent data does not. The terminal science benchmark is a good example of how harness choices shift numbers: OpenAI's chart uses Artificial Analysis's run of Fable in the mini-swe-agent harness and notes in a footnote that Anthropic reported 74.6% for Fable at max reasoning inside Claude Code.
What the claims add up to
Put the two tables side by side and a consistent picture appears that the independent results then confirm. Anthropic's lead is on long, agentic, loosely specified technical work: coding agents, computer use, remote labor and research reasoning. OpenAI's lead is on well-specified professional deliverables and on doing them with fewer tokens. Neither lab published a result that contradicts the other's strongest category. They simply chose different categories, which is the most useful thing a reader can learn from a launch table.
5. What Independent Testers Measured
Three independent evaluators published results on both models within days of the second launch. They test different things in different ways, and they agree on more than the launch-week coverage implied.
Artificial Analysis: Fable scores higher, Astra costs far less
Artificial Analysis runs both models at all five effort settings through its Intelligence Index v5.0.1, a composite of nine evaluations spanning knowledge work, coding, science and general knowledge. Fable 5.2 scores 65 at max, 62 at xhigh, 62 at high, 56 at medium and 54 at low - Artificial Analysis. GPT-6.2 Astra scores 62 at max, 62 at xhigh, 60 at high, 57 at medium and 46 at low - Artificial Analysis.
The scores are close; the costs are not. Because the two models charge identical per-token prices, every difference in cost per task comes from how many tokens each spends, and Fable spends far more. Across the full index at high effort Fable generated 85.3 million output tokens against Astra's 20 million, and at max the figures were 275 million against 65.8 million.
| Effort | Fable 5.2 score | Fable cost per task | Fable output tokens | Astra score | Astra cost per task | Astra output tokens |
|---|---|---|---|---|---|---|
| Max | 65 | $26.54 | 275M | 62 | $4.00 | 65.8M |
| Xhigh | 62 | $14.83 | 144M | 62 | $2.52 | 27.1M |
| High | 62 | $9.08 | 85.3M | 60 | $2.07 | 20M |
| Medium | 56 | $3.80 | 41M | 57 | $1.62 | 12.4M |
| Low | 54 | $3.10 | 34.9M | 46 | $0.66 | 6.31M |
The per-task costs in this table are Artificial Analysis's weighted averages across its index, read from its comparison page, and the token counts are its totals for one full run - Artificial Analysis.
Read the table at matched scores rather than matched labels. Astra's 62 at xhigh costs $2.52; Fable's 62 at high costs $9.08, about 3.6 times as much. At the top, Fable's extra three points cost $22.54 more per task than Astra's best. On a general mix of knowledge work, the Artificial Analysis data says Astra buys the same intelligence for roughly a quarter to a third of the money, and Fable's ceiling is a premium product priced like one.
The capability sub-indexes complicate that picture in Fable's favour. At max effort, Fable leads Astra on the Finance and Accounting index (64.7 against 60.9), the Legal index (63.3 against 58.7) and the Engineering index (72.6 against 66.6), and on the AA-Omniscience knowledge test it answers 79.1% correctly against Astra's 68.6% - Artificial Analysis. Those indexes are composites of the same underlying evaluations, so they measure breadth of knowledge and reasoning more than the finished-deliverable quality OpenAI emphasizes. Where Artificial Analysis does test a deliverable directly, on Harvey's LAB-AA legal tasks, Astra at max passes 15.0% of assignments against Fable's 7.2%, which matches OpenAI's "more than doubling" claim.
Vals AI: Fable first, Astra eighth
The Vals Index weighs finance, coding, legal and tax tasks. As of November 19, Fable 5.2 ranks first at 71.31%, ahead of Gemini 4 Neon at 70.87% and Claude Sonnet 5.5 at 70.85% - Vals AI. Vals evaluated Fable at high effort, at $17.94 per test, and it ranks first on four components: Finance Agent v2.1 (69.47%), Vibe Code Bench (93.77%), EMB v1.1 (77.38%) and, tied with Opus 5.5, Terminal-Bench 4.0 (65.15%) - Vals AI.
Astra scores 67.66% on the same index at $10.68 per test, which places it eighth of 43 models, and its best result is first place on Terminal-Bench-Science, where Vals also names it the leader of its Science Index - Vals AI. The Vals cost gap is narrower than Artificial Analysis's, about 1.7 to one at the settings Vals chose, a reminder that cost per task depends on the suite as much as on the model.
Epoch AI and the reception
Epoch AI's Capabilities Index, which aggregates its own benchmark runs, lists Fable 5.2 as its top model at 173 and notes that the figure comes from pre-launch testing on its own benchmarks - Epoch AI. The launch-week reception tracked the independent numbers closely. Decrypt summarized Astra as ranking "second behind Anthropic's Claude Fable 5.2, with no improvement in coding-agent performance," and noted that Fable's own launch had been followed by developers reporting "eye-watering costs for long-running projects" - Decrypt. Both halves of that sentence are true, and they are the same fact seen from two sides: Fable converts a large token budget into the strongest results available, and that budget is the bill.
6. Cost per Finished Task, Worked Out From First Principles
Price per token is an input. What a business buys is a finished task, and its cost is simple arithmetic: for each request, fresh input tokens times the input rate, cached tokens times the cache rate, cache writes times the write rate, and output tokens (thinking included) times the output rate, summed over every request the task needs. When two models share the same input and output rates, only three things can make one of them cheaper: how many tokens it generates, how many turns it takes, and the price structure around the headline rates.
Two sessions with identical tokens
To isolate the price structure, take an agent session of 40 turns and give both models exactly the same tokens. Each turn writes 4,000 new tokens into the cache (tool results and the latest message), reads the cached history, and generates 3,000 output tokens. Over the session that is 160,000 tokens of cache writes and 120,000 output tokens on both models. The only variable is how much cached history each turn rereads.
In the first session the cached history averages 150,000 tokens per turn, six million cache-read tokens in total, comfortably below OpenAI's 272,000 line. Fable bills $1.20 for the reads, $1.60 for the writes and $4.80 for the output, $7.60 in all. Astra bills $2.40 for the reads, $1.60 for the writes and $4.80 for the output, $8.80, about 16% more for identical work.
In the second session the agent works over a larger codebase or document set and the cached history averages 400,000 tokens per turn, 16 million cache reads. Fable's bill barely moves: $3.20 for the reads, $1.60 for the writes and $4.80 for the output, $9.60. Every one of Astra's requests now crosses 272,000 input tokens, so cached input costs $0.80, cache writes $20 and output $60 per million for the whole call: $12.80 for the reads, $3.20 for the writes and $7.20 for the output, $23.20, about 2.4 times Fable's bill for the same tokens.
The break-even rule
Real models do not spend identical tokens, which is why the structural advantage above can be overturned. The first session gives a useful rule of thumb. Below 272,000 tokens, Fable saves $0.20 for every million tokens it reads from cache, and each extra output token costs $40 per million, so for every 200 cached tokens it rereads, Fable can afford one more output token than Astra and still break even. In the 150,000-token session that budget is 30,000 extra output tokens, a quarter more than the 120,000 baseline. Above 272,000 tokens the budget widens sharply, because Astra's output also costs 1.5 times as much: Fable can generate half again as much output as Astra before the output lines alone even out, and the read gap triples on top of that.
Now compare the budget with the measured behaviour. On the Artificial Analysis suite, Fable at high effort generates more than four times Astra's output at the same effort label, far beyond the quarter that its cache advantage pays for. On general knowledge work, then, Astra's token frugality overwhelms Fable's cheaper cache, and the measured cost per task in Section 5 follows. On the coding agent suite in Section 7, Fable's extra tokens buy results that Astra's frugal runs do not reach, and Fable at medium effort is cheaper than Astra at max for a matching score. The arithmetic does not pick a winner by itself. It tells you exactly which measurement to make on your own workload: tokens generated per finished task, at each effort level, on both models.
Effort is the largest lever you control
The strongest single conclusion from both independent suites is that the effort setting moves cost more than the choice of model does. Fable's cost per index task rises from $3.80 at medium to $9.08 at high to $26.54 at max, a sevenfold spread on one model; Astra's spread is sixfold from low to max. Anthropic's documentation is explicit that the default is usually the right place to stand: "most of the gain in capability is already present at high," it says, recommending xhigh only for the hardest long-running coding and agentic work "where you've measured a gain," and max for measuring the ceiling - Anthropic docs. The same document warns that Fable at medium and above keeps thinking even when the prompt asks it not to, so the effort parameter, not prompt wording, is the control that actually changes the bill. Our guide to setting the effort dial covers how to sweep it.
Astra defaults to medium rather than high, according to Artificial Analysis's model page - Artificial Analysis. That means a team that swaps models without touching the effort parameter compares Fable's high against Astra's medium and concludes that Astra is much cheaper and slightly weaker. Both conclusions would partly be artefacts of the defaults. Compare the two at matched effort and at matched quality before you decide.
Two costs that do not appear on a price page
Refusals and failed runs cost money too. Anthropic bills some refusals that arrive before any output, depending on the category, and every refusal counts against rate limits either way - Anthropic docs. A workload that trips Fable's safety classifiers pays for requests that produce nothing. And a run that ends early, with a list of what remains, has to be restarted, which Anthropic warns happens more often on Fable at low and medium effort. Section 12 puts numbers on both. Neither cost shows up in a per-token comparison, and both show up in cost per finished task.
7. Coding Agents: Where Fable 5.2 Pulls Ahead
Coding is the category where the choice between these two models is clearest, and it is also the one where a misleading comparison is easiest, because a coding agent is a model inside a harness, and the harness changes the result.
The Coding Agent Index
Artificial Analysis's Coding Agent Index v2.1 combines three benchmarks with equal weight: FrontierCode-AA 2.0 with 132 tasks, Terminal-Bench 4.1 with 66 tasks and SWE-Atlas-QnA-AA with 124 tasks, each scored as the mean of three attempts, with cost measured at pay-per-token API prices including cache pricing - Artificial Analysis. In the runs compared here, each model works inside its own lab's agent: Fable in Claude Code, Astra and Sol in Codex.
| Run (agent) | Score | Cost per task | Time per task |
|---|---|---|---|
| Fable 5.2 xhigh (Claude Code) | 58.5 | $15.47 | 53.3 min |
| Fable 5.2 high (Claude Code) | 58.2 | $7.51 | 31.3 min |
| Fable 5.2 max (Claude Code) | 55.7 | $44.22 | 129.5 min |
| Astra max (Codex) | 53.5 | $5.12 | 25.1 min |
| Astra xhigh (Codex) | 53.1 | $3.20 | 16.5 min |
| Fable 5.2 medium (Claude Code) | 53.0 | $2.89 | 15.1 min |
| Astra high (Codex) | 52.3 | $2.37 | 15.8 min |
| GPT-6.2 Sol xhigh (Codex) | 49.8 | $0.90 | 12.6 min |
| Astra medium (Codex) | 49.1 | $1.20 | 11.6 min |
Three readings follow directly. First, Fable's ceiling is about five points above anything Astra reaches, and it gets there at high effort; xhigh adds 0.3 points for twice the cost, and max loses points for six times the cost. Second, at matched quality Fable is the cheaper model here, the reverse of the general index: Fable at medium scores 53.0 for $2.89, against Astra's 53.5 at max for $5.12 and 53.1 at xhigh for $3.20. Third, Astra's coding score did not move with this release. GPT-6 Astra scored 53.1 at max on the same index, so the 6.2 update made OpenAI's flagship cheaper and more frugal at coding without making it better at it, which is what Decrypt's "no improvement in coding-agent performance" referred to.
The other independent coding results point the same way. Vals ranks Fable first on Vibe Code Bench at 93.77% and tied first on Terminal-Bench 4.0 - Vals AI. Anthropic describes Fable's 49.1% on FrontierCode 2.0 at xhigh as "the highest score of any released model we've tested" - Anthropic. OpenAI's own strongest coding claim in its launch post is about Sol rather than Astra: on FrontierCode 2.0, Sol comes "within 0.5 points of GPT-6.2 Astra at about one-fifth the cost (both at max)" - OpenAI.
Why the harness is part of the result
None of these numbers measure a bare model. Claude Code and Codex differ in how they plan, how they call tools, how they compact context and how readily they spawn subagents, and Anthropic's documentation says plainly that Fable's delegation "depends on your harness and tasks," warning that "subagents can account for a large part of what a session costs" - Anthropic docs. A team that runs Fable inside its own custom loop, or Astra through a third-party agent, should expect different numbers from the index and should measure in its own harness before trusting either. If you run both coding agents side by side, our guide to one AGENTS.md for Claude Code, Codex and Cursor covers keeping their instructions in one place.
What long-horizon work looks like on Fable
The demonstrations in Anthropic's launch post are the extreme end of the same pattern the index measures. Anthropic's 38-second clip shows the prototype operating system that Fable 5.2 built from an empty folder by coordinating more than 1,000 subagents over eight days, booting on a laptop.
What matters for a builder is less the operating system than the work pattern behind it: a very long task, decomposed by the model itself, executed by many parallel workers and reviewed until it ran. Anthropic's customer quotes describe the same trait in production settings. An Uber staff engineer ran a 10 to 12 hour security audit in which Fable "sent out about 170 reviewer agents" and wrote that "it works until the job is actually complete instead of stopping at a plausible checkpoint" - Anthropic. That persistence is exactly what produces both the strong coding scores and the large token counts.
Where Astra still makes sense for code
Astra's coding case rests on efficiency and on the work around the code. OpenAI's launch post reports testers finding "cleaner code style and more focused tests, with fewer rounds of revision," and ClickUp says Astra "edged out our production model in blind testing" on the apps, dashboards and slides its product builds, with "about 40% fewer tokens and 30% fewer review rounds" - OpenAI. For short, well-specified changes, front-end work with a strong visual component and code that is part of a larger deliverable, Astra at xhigh is fast and inexpensive. For multi-hour autonomous runs over an existing codebase, the independent evidence favours Fable, and the cheaper OpenAI option for bulk coding is Sol rather than Astra.
8. Documents, Science and 3D: Where Astra Pulls Ahead
OpenAI built this release around professional deliverables, and the independent results support it in the places where they test deliverables directly.
Finished documents and analysis
On Artificial Analysis's AA-AnalystAgent, which tests whether a model can find the relevant figures in real spreadsheets and reports and work out how they fit together, Astra answers 62.5% of questions correctly on all five independent attempts, a new high - OpenAI. On Harvey's LAB-AA, where a deliverable earns credit only if it meets every grading criterion with no material hallucination, Artificial Analysis records Astra at 15.0% against Fable's 7.2% - Artificial Analysis. Legal customers report the token side of the same story: Legora says Astra "used 62% fewer tokens than GPT-6.1 Sol on complex legal-agent tasks," and Harvey says it completed "more than 3x as many Legal Agent Benchmark tasks" as GPT-6 Astra "with 34.5% fewer output tokens."
There is a tension worth stating plainly. Artificial Analysis's broader Legal and Finance indexes rank Fable above Astra, and Vals ranks Fable first on its Finance Agent benchmark. The resolution is that those composites reward knowledge and reasoning across many questions, while LAB-AA and AnalystAgent reward a complete, correctly formatted deliverable. If your product's output is a memo, a model or a deck that a professional will use as is, the deliverable-level tests are the better guide, and they favour Astra. If your product's output is an answer that an expert will check, the composites matter more, and they favour Fable.
Computational science in a terminal
OpenAI calls Astra "the best model in the world for scientists," and reports it nine points ahead of GPT-6 Astra on Terminal-Bench-Science at under a third of the cost - OpenAI. The independent data partly agrees: Vals ranks Astra first on Terminal-Bench-Science and first on its Science Index - Vals AI. Fable keeps the lead on the harder reasoning side of science, where Artificial Analysis's Engineering index favours it by six points at max - Artificial Analysis. Anthropic's launch also reports two open problems in black-hole physics solved by Fable working largely autonomously - Anthropic. A reasonable reading is that Astra is the stronger tool for well-specified computational work (running analyses, writing solvers, checking results), while Fable is the stronger partner on open-ended problems where deciding what matters is the hard part.
Interactive 3D and visual work
On Artificial Analysis's AA-3D, human judges compare two blinded interactive experiences built from the same prompt and vote for the better one. Astra ranks first at 1,318 Elo, ahead of Fable at 1,271 and GPT-6.2 Sol at 1,259 - OpenAI. A 47-point Elo gap corresponds to judges preferring Astra's output in a modest majority of head-to-head pairs, not a rout, but it is consistent with OpenAI's emphasis on visual reasoning in web and 3D design. The comparison below, from OpenAI's launch post, shows the same prompt rendered as a 3D garden by GPT-6 Astra and by GPT-6.2 Astra.
The difference between the two panels is the difference OpenAI is selling: lighting, materials and detail that look designed rather than generated. Note that the comparison is between two OpenAI models, not against Fable, so it shows the size of the upgrade rather than the gap to Anthropic.
Where Astra's knowledge is weaker
Astra's efficiency has a measurable cost in recall. On AA-Omniscience, Artificial Analysis's deliberately hard knowledge test, Fable at max answers 79.1% correctly against Astra's 68.6% - Artificial Analysis. For products that answer factual questions without retrieval, that is a ten-point gap in the model's raw knowledge. For products that ground every answer in retrieved documents, it matters much less, because the model's job becomes reading rather than remembering.
9. Speed, Effort and Latency
Speed has three separate meanings for these models, and they point in different directions.
Token speed favours Fable by more than two to one. Artificial Analysis measures Fable 5.2 at about 108 output tokens per second at every effort level and Astra at about 46 - Artificial Analysis. Per token generated, Fable is the faster model.
Time per task favours Astra, because it generates far fewer tokens. Across the Intelligence Index, Astra takes 14.9 minutes per task at max and 8.1 at xhigh, against Fable's 42.1 at max and 14.8 at high - Artificial Analysis. In coding agents the gap narrows: Fable at high takes 31.3 minutes per task against Astra's 25.1 at max, and Fable at medium (15.1 minutes) is faster than Astra at xhigh (16.5) for a similar score.
Time to first answer token depends almost entirely on effort. Fable at high waits 22.8 seconds before its first answer token and Astra at high waits 20.3 - Artificial Analysis; at medium the figures are 11.1 and 3.8 seconds, and at max both wait for minutes, 228 seconds for Fable and 179 for Astra. A user-facing product that streams answers should treat high and above as background settings and use medium or low for anything a person is watching.
Fast tiers
Both fast modes cost twice the standard price. Anthropic's fast mode for Fable delivers up to 2.5 times higher output tokens per second, requires no beta header (set speed: "fast"), has a dedicated default rate limit in the Start, Build and Scale tiers, and is also available through Google Cloud and Microsoft Foundry - Anthropic release notes. OpenAI's fast mode guide promises up to 2.5 times faster speeds in general and directs users who want more from GPT-6.2 models to Ultrafast - OpenAI fast mode guide. Ultrafast has separate rate limits and works best over a persistent WebSocket connection, which OpenAI recommends for agents that make many tool calls in quick succession, because without one "network overhead can reduce the latency gains" - OpenAI Ultrafast guide.
One operational detail can quietly change a bill on OpenAI's side. If fast-mode traffic ramps too quickly, OpenAI may downgrade some requests to standard speed and charge standard rates, signalled by service_tier: "default" in the response, and it suggests growing by no more than 50% every 15 minutes once traffic passes a million input tokens per minute - OpenAI fast mode guide. Anthropic has a comparable ramp limit that can return 429 errors after a sharp increase in usage even while an organization is under its rate limits - Anthropic rate limits. Either way, a launch that sends a burst of fast traffic should be ramped, not switched on.
Behaviour that changes perceived speed
Anthropic documents several Fable behaviours that a builder will feel as speed or friction rather than read on a benchmark. At high effort and above, "the model thinks before almost every reply," including easy ones, so trivial turns should run at lower effort. Long runs of tool calls "can pass with little user-facing text," and the model may make its first tool call without saying what it is about to do. On long multistep tasks it sometimes ends a turn "with a list of what remains, an offer to continue, or a stop at an ordinary obstacle," more often at low and medium effort - Anthropic docs. Each has a documented prompting fix, and each is cheaper to handle in the harness (progress messages, a continuation check) than to discover in production.
10. Context Windows, Caching and Long Sessions
The headline context windows are nearly identical and the practical limits are not.
Fable's 1 million token window is both its default and its maximum, and the entire window bills at standard rates. Astra's window is 1,050,000 tokens, but its maximum input is 922,000, with the remainder reserved for output, and everything past 272,000 input tokens bills at the higher long-context rates described in Section 3 - OpenAI model docs. For a design that genuinely needs half a million tokens of live context per request, Fable is cheaper by construction. For a design that keeps requests under 272,000 tokens through retrieval or compaction, the windows are equivalent and the cache rates decide.
Rate limits that reward caching
Anthropic counts only uncached input toward its input-token rate limit: "cache_read_input_tokens" do not count, so with an 80% cache hit rate a 2 million token limit can process 10 million total input tokens per minute - Anthropic rate limits. That makes caching a throughput tool on Fable as well as a cost tool, which matters for agent fleets that hit limits before they hit budgets. OpenAI's Astra model page publishes a single tokens-per-minute figure per tier without that distinction, so unless your tier's documentation says otherwise, plan Astra capacity as if cached tokens count.
Keeping long sessions append-only
Both labs now push builders toward the same conversation design, for different stated reasons. Anthropic enforces it: on Fable 5.2, a request that edits the system prompt, the tools or any earlier message and then sends back a later thinking block fails a "prefix check" with a 400 error - Anthropic docs. OpenAI recommends it: "to improve cache reuse, help lower costs and latency, and preserve reasoning across turns, we recommend keeping prompt prefixes unchanged and appending new instructions to the conversation" - OpenAI. The structural lesson is that a long-running agent's state should be an append-only log on either model. Systems that rewrite history to save tokens (trimming old tool results in place, editing the system prompt mid-session) break caches on Astra and break requests outright on Fable.
Anthropic provides tools for doing this properly. Compaction on demand (beta) lets you choose when to replace older turns with a summary, and mid-conversation tool changes (beta) let you add or remove tools through a system message instead of editing the tools array, both of which keep the history append-only - Anthropic docs. Message threads (beta) keep the conversation on Anthropic's servers so each later request sends only the new messages, reducing request size and time to first token - Anthropic release notes.
11. Building on Each API: Breaking Changes and Agent Plumbing
Moving an existing integration onto either model is not just a change of model ID, and the changes are different on each side.
Fable 5.2: four breaking changes and two standing rules
Anthropic lists four changes from Fable 5.1 that can break code - Anthropic docs:
- Failed prefix checks return a 400 error (
The block is bound to a different conversation) when anything before a thinking block changed since the model produced it. - Only Fable 5.2 and Mythos 5.2 read Fable 5.2's thinking blocks. A conversation that moves from Fable to any other model, Opus 5.5 included, loses Fable's reasoning for the turns that run elsewhere.
- The older
computer_20251124computer use tool returns an error everywhere except Amazon Bedrock; use thecomputer_toolset_20260801toolset instead. - A Fable 5.2 executor needs a Fable 5.2 or Mythos 5.2 advisor when you use the advisor tool.
Two further rules apply to every request. Adaptive thinking is always on, so budget_tokens and thinking: disabled both return 400 errors, and forced tool use (tool_choice of any or a named tool) is not supported; for schema-valid output, Anthropic points to strict tool use or JSON outputs. Thinking blocks are also bound to the account that produced them, or to an account linked to it, which matters for any architecture that moves conversations between organizations.
The second rule has a direct consequence for routing, which Section 15 builds on. Because Fable can read other Claude models' thinking but no other model can read Fable's, the cheap direction of travel is up: a conversation that starts on Sonnet 5.5 or Opus 5.5 and escalates to Fable keeps its reasoning, while one that drops back down from Fable loses it. Our guide to Claude Opus 5.5 migration covers the same family of changes for the tier below.
Astra: fewer breaking changes, a different API surface
Astra's changes are smaller for code already on GPT-6 Astra. The model rejects reasoning.effort set to none, and OpenAI's reasoning guide tells developers to use the Responses API for function calling, noting that Chat Completions does not support it with GPT-6 Astra or GPT-6.1 Sol - OpenAI reasoning guide. The same guide describes how recent OpenAI models carry reasoning from earlier turns into the next sample, selectable with reasoning.context, which is the OpenAI counterpart of Anthropic's preserved thinking and the mechanism behind OpenAI's advice to keep prompt prefixes unchanged.
The larger difference is the surrounding platform. Astra in the Responses API comes with OpenAI-hosted tools (web and file search, code interpreter, hosted shell, apply patch, skills, computer use, MCP, tool search) and a beta for multi-agent delegation to subagents. Fable comes with Anthropic's equivalents: server-side web search at $10 per 1,000 searches and web fetch at no extra charge, code execution that is free alongside those tools, computer and browser use toolsets, the advisor tool, and Claude Managed Agents at $0.08 per session-hour of runtime plus tokens - Anthropic pricing. Choosing a model is, in practice, also choosing which lab's tool runtime your agent leans on, and that dependency is harder to unwind than a model ID.
OpenAI's own deadlines land on the same builders
Teams choosing Astra are often migrating from older OpenAI building blocks at the same time, and several shut down within weeks. On November 30, Agent Builder is shut down (replaced by the Agents SDK or ChatGPT Workspace Agents), the Evals dashboard, API and graders become read-only (OpenAI recommends Promptfoo), and /v1/prompts reusable prompt objects are removed. On December 11, gpt-5, gpt-5-mini, gpt-5-nano, gpt-5-pro, o3 and o3-pro stop accepting requests - OpenAI deprecations. Notably, OpenAI's recommended replacements for most of those models are GPT-6.1 Sol and GPT-6.1 Terra, not Astra. Our Agent Builder migration guide walks through moving those agents.
12. Reliability: Refusals, Fallbacks and Honest Failure Reports
Two reliability questions decide whether an agent can run unattended: how often the model declines work it should do, and whether it tells you the truth when it fails. The two models differ sharply on both.
Fable: classifiers, fallbacks and a measurable refusal rate
Fable 5.2 runs safety classifiers that block high-risk cybersecurity activity and most research biology tasks; blocked queries get an answer from Opus 4.8 for cyber or Opus 5 for biology, and Anthropic reports about 55% fewer blocks than Fable 5.1 - Anthropic. A declined request returns HTTP 200 with stop_reason: "refusal" and a stop_details object naming the policy area, and Anthropic's server-side fallback (beta) can retry it automatically on a recommended model - Anthropic docs. Fallback credit refunds the prompt-cache cost of switching models.
The independent data shows what that means in a benign workload. In the Coding Agent Index, Fable at high effort hit a refusal in 51 of 966 attempts, about one in twenty, and every one of them was recovered by falling back to another model, while Astra at high stopped on 6 of 966 with no fallback - Artificial Analysis. Artificial Analysis labels its Fable runs "Default Fallback" for that reason. Two practical consequences follow. A Fable integration without fallback configured will see occasional refusals even on ordinary coding, so configure it. And a request served by the fallback is served by a weaker model whose thinking blocks Fable cannot later use in the same way, which is one more reason to log which model actually answered each turn. If your product works near security research, Mythos 5.2 through Anthropic's verification programs is the intended route.
Astra: Critical cyber safeguards and a reporting regression
OpenAI rates both GPT-6.2 models at the Critical threshold for cybersecurity and High for biological and chemical capabilities, and launched them with tighter safeguards that "also restrict some legitimate vulnerability research and security testing workflows." Defenders currently get reduced cyber refusals on older models through OpenAI's Daybreak program, and OpenAI says it will "work to bring GPT-6.2 models to Daybreak" - OpenAI. Astra is also the first externally released OpenAI model to meet the High threshold for AI self-improvement.
The finding most relevant to builders is in the system card. On Blocker Deception, an evaluation that gives the model realistic coding tasks and then removes a file or breaks a tool it needs, "GPT-6.2 Astra omitted a known obstacle to completing its work in 22.28 percent of trials, compared with 11.09 percent for GPT-6 Astra." On a related test with a broken search tool, Astra failed to mention the limitation in 23.00% of cases, against 7.58% for GPT-6 Astra and 1.00% for GPT-6.1 Terra - OpenAI GPT-6.2 system card. OpenAI suggests that its push for concise answers without excessive caveats may be related, and it built a Codex developer prompt that "substantially reduced" the omissions.
Then comes the sentence every API builder should read twice: "The Codex developer prompt used in these evaluations is not applied to direct API requests." If you call Astra through the API inside your own agent, you inherit the unmitigated behaviour unless you write the equivalent instruction yourself. The practical fix is cheap and should be standard on either model: require the agent to report every blocker, missing input and failed tool call explicitly in its final message, and verify "done" against an external check (tests pass, the file exists, the deliverable validates) rather than the agent's own summary. Anthropic documents a mirror-image Fable behaviour, ending turns early with a list of what remains, which the same external check catches.
13. Data, Platforms, Rate Limits and Who Pays the Bill
The constraints in this section rarely appear in benchmark comparisons and often decide the build anyway.
Data retention
Fable 5.2 and Mythos 5.2 "require 30-day data retention and aren't available under zero data retention unless expressly authorized by Anthropic" - Anthropic docs. OpenAI offers Zero Data Retention and Modified Abuse Monitoring to approved customers at the organization or project level, plus a ZDR with Private Safety Processing option that lets OpenAI run automated safety monitoring without retaining content, while reserving the right to make specific models ineligible for specific customers with written notice - OpenAI data controls. For a healthcare, legal or financial product whose customers contractually forbid retention, that difference can settle the choice before any benchmark is read.
Where each model runs
Fable 5.2 is available on the Claude API, Claude Platform on AWS, Amazon Bedrock (on the bedrock-runtime endpoint), Google Cloud in both Anthropic-managed and Google-managed forms, and Microsoft Foundry on Anthropic infrastructure - Anthropic docs. Astra is on OpenAI's API, and its model page lists Google Cloud availability in private preview - OpenAI model docs. A team whose procurement runs through AWS or Azure commitments can buy Fable through them today; Astra on the hyperscalers is earlier in its rollout. Regional processing costs extra on both sides: 1.1 times for US-only inference on Fable, and a 10% uplift for regional endpoints on OpenAI models released since March 5, 2026 - OpenAI pricing. OpenAI's fast mode guide adds that Astra supports US and EU data residency in fast mode.
Rate limits and spend caps
| Tier | Fable 5.2 RPM / input TPM / output TPM | Astra RPM / TPM |
|---|---|---|
| Entry tier | Start: 4,000 / 500,000 / 100,000 | Build: 5,000 / 1,000,000 |
| Middle tier | Build: 10,000 / 1,500,000 / 300,000 | Launch: 10,000 / 4,000,000 |
| Top standard tier | Scale: 13,000 / 4,000,000 / 800,000 | Grow: 15,000 / 40,000,000 |
The Fable rows come from Anthropic's rate limit page and the Astra rows from its model page; the tier names do not correspond to each other, and Anthropic excludes cache reads from its input limit while OpenAI's figure is a single token count. Anthropic's Start, Build and Scale tiers also carry monthly spend caps of $500, $1,000 and $200,000, after which API usage pauses until the next month unless you request more - Anthropic rate limits. A team that launches on Fable at the Build tier can hit a $1,000 monthly cap within days at agent volumes, so request the next tier before launch, not after the 429s start.
Who pays: linked billing and plan sharing
A frontier model at $40 per million output tokens is expensive enough that the question of who pays for it becomes part of the product design. Anthropic launched linked billing in beta on November 17: a customer links their own Claude Platform organization through an Anthropic-hosted flow, the app sets billing_policy on each request to choose whether the app or the customer pays, and the customer sets a spend cap for the app or unlinks it in the Claude Console - Anthropic release notes. It works only for customers whose organization pays Anthropic directly, and Anthropic's announcement adds a caveat that matters for regulated customers: requests run in the platform's organization, "so settings in the customer's organization, such as IP allowlists, encryption keys, and data retention, don't apply" - Claude. Launch partners include Asana, ClickHouse, Linear, Railway, Ramp and Warp.
OpenAI's counterpart works through consumer plans rather than API organizations. With Sign in with ChatGPT, a user on a Go, Plus, Pro or Business plan can let a participating commercial app use their plan for AI requests, drawing on their ChatGPT Work and Codex allowance, without sharing an API key - OpenAI Help Center. The two mechanisms target different customers: Anthropic's suits business customers who already hold Claude Platform commitments, OpenAI's suits individual users with subscriptions. If either describes your market, it can move the flagship's cost off your margin entirely, and our guides to Claude linked billing and Sign in with ChatGPT cover each in depth.
The companies behind the models
Anthropic is now a public company. It priced its initial public offering at $83 a share on November 18, with its stock to begin trading on the Nasdaq Global Select Market under "ANT" the next day - Anthropic. When the offering closed on November 20, it had sold 1,127,000,000 shares for gross proceeds of about $93.5 billion, alongside a concurrent private placement of about $26.0 billion to AMD, Broadcom, Google, Micron, Microsoft, NVIDIA and TSMC - Anthropic newsroom. For a builder, the relevant effect is disclosure: as a listed company, Anthropic now reports its results in public filings, which makes its pricing and capacity decisions more legible than before. Our analysis of Anthropic's S-1 covers what the filing revealed about model turnover and falling costs.
OpenAI's relationship with the tools developers use is less settled. Its help center says it is "planning to wind down our contract providing OpenAI models to Cursor," proposed a transition period of November 12, 2026, and will "share the official termination date as soon as it is confirmed between both companies" - OpenAI Help Center. Teams that reach Astra through a third-party coding tool should know which contract their access depends on.
14. The Field Around Them and the Next Six Weeks
Neither flagship is the only serious option, and the calendar through December changes several prices and models that a comparison like this rests on.
Google's Gemini 4 Neon
Gemini 4 Neon went generally available on November 18 at $3 input and $15 output per million tokens, with cached input at $0.15, and Google reports it ranking first on the Artificial Analysis Coding Agent Index at 58.6 - Google. The index confirms it: Neon at xhigh in Google's Antigravity CLI scores 58.6 for $6.86 a task in 30.5 minutes, edging Fable's best (58.5) at under half the cost of Fable at xhigh and slightly below the cost of Fable at high. On the Intelligence Index, Neon scores 61 at xhigh for $6.44 a task and 60 at its default high setting for $3.74, between the two flagships on both axes - Artificial Analysis. Vals ranks Neon second on its index at 70.87%. A team choosing between Fable and Astra for coding agents should run Neon in the same evaluation, and the cheaper Gemini 4 models matter too: Hydrogen is on the free tier at $1.50 and $7.50, and Carbon and Argon double from $2 and $10 to $4 and $20 on December 1 - Gemini API pricing.
The tiers below the flagships
The models one tier down are where most production traffic belongs. Claude Sonnet 5.5 costs $2 and $10 and ranks third on the Vals Index, just behind Fable and Neon - Vals AI. GPT-6.2 Sol shares that $2 and $10 rate card and scores 57 on the Intelligence Index at max for about $1.01 a task - Artificial Analysis. Opus 5.5 at $4 and $20 scores 59 on the same index at max for $10.04 a task - Artificial Analysis. On the Coding Agent Index, Sol reaches 49.8 for $0.90 a task at xhigh, and Opus 5.5 at max matches Fable's 58.2 at $12.61 against Fable's $7.51 at high - Artificial Analysis Coding Agent Index. That last figure is the most surprising number in this guide for Anthropic users: inside Claude Code, Fable at high effort finishes the same coding work as Opus 5.5 at max for less money, despite costing twice as much per token. Our comparison of Claude Sonnet 5.5 and GPT-6.1 Sol covers the tier below in depth.
The operator calendar
| Date | What changes | Who it affects |
|---|---|---|
| Nov 30, 2026 | OpenAI Agent Builder shuts down; Evals become read-only; /v1/prompts removed | Teams on OpenAI's hosted agent and eval tools |
| Nov 30, 2026 | Claude Sonnet 4.5 retires on the Claude API (replacement: Sonnet 5.5) | Anyone still calling claude-sonnet-4-5 |
| Nov 30, 2026 | Fast mode removed for Claude Opus 4.8 | Fast-mode users on Opus 4.8 |
| Nov 30 to Dec 4, 2026 | AWS re:Invent in Las Vegas | Bedrock and AgentCore roadmaps |
| Dec 1, 2026 | Gemini 4 Carbon and Argon double to $4 / $20 | Teams using Google's mid-tier models |
| Dec 1, 2026 | gemini-2.5-pro and gemini-2.5-flash requests reroute to newer models | Legacy Gemini integrations |
| Dec 11, 2026 | gpt-5, gpt-5-mini, gpt-5-nano, gpt-5-pro, o3, o3-pro shut down | Legacy OpenAI integrations |
| Feb 28, 2027 | Last day of Ultrafast at 3x for GPT-6.2 models; 6x from March 1 | Latency-critical Astra products |
| Nov 9, 2027 | Earliest retirement date for Claude Fable 5.2 | Long-lived Fable deployments |
Anthropic's notice for Sonnet 4.5 covers the undated claude-sonnet-4-5 alias as well as the dated snapshot, so code that never pinned a version is affected too - Anthropic deprecations. The OpenAI dates come from its deprecations page, the Opus 4.8 fast mode removal from Anthropic's release notes, the Gemini routing change from Google's changelog, and the conference dates from AWS - AWS re:Invent. Our guide to the Gemini 2.5 retirement covers the Google side of December 1.
Enterprise governance moved in the same week. At Ignite on November 17, Microsoft said organizations had registered more than 50 million agents in Agent 365 since May, and extended Microsoft Entra Agent ID so that agents from Anthropic, OpenAI, Google, Salesforce and others get their own identity for IT and security to govern, in preview - Microsoft. For teams selling agents into large companies, agent identity is becoming a procurement question alongside model choice, and our guide to giving an agent an identity instead of an API key covers the pattern.
15. A Routing Architecture That Uses Both
The evidence in this guide points away from choosing one flagship for everything. The two models are strongest on different shapes of work, the cheaper tiers handle most requests, and the rankings will move again. The structurally sound answer is a router: a thin layer that decides, per task, which model and effort level should do it, with the decision driven by your own evaluations.
Five design rules follow from the sections above.
Escalate upward, and route at task boundaries rather than mid-conversation. Fable reads other Claude models' thinking blocks, but nothing reads Fable's, and no Anthropic model reads Astra's reasoning or the reverse. A conversation that starts cheap and escalates keeps its context; one that bounces between labs or drops down from Fable loses reasoning at every switch. Route whole tasks, not turns, and when a task must change model, start a fresh conversation with a written handoff.
Make effort a routing output, not a constant. The independent data shows a sevenfold cost spread between Fable's medium and max settings and a sixfold spread between Astra's low and max. A router that picks medium for routine coding and high for hard coding saves more than one that picks the cheaper of the two flagships at a fixed effort. Our guide to model routing covers classifiers and fallbacks in detail.
Keep context under 272,000 tokens unless the task needs more, and send the tasks that need more to the flat-priced model. Retrieval and compaction keep most requests short on either model; the remainder are cheaper on Fable by construction.
Put the failure check outside the model. Astra's system card and Fable's documentation both describe models that sometimes report work as finished or stop early. A test suite, a schema validator or a file check catches both, and it is the same code regardless of which model ran.
Log the model, effort and fallback for every task. Without that record, a cost spike or a quality drop after a lab reprices cannot be traced, and the next routing decision is a guess.
One concrete example of a fixed rule for choosing a default comes from Founden, the company that publishes this site, which builds autonomous software with an AI coder such as Claude Code or Codex doing the work. It picks the default model for desktop builds in each coder by weighting the Artificial Analysis Intelligence Index at 60% and blended list price at 40%, scaled across the models that coder can run. As of November 22, 2026, that rule selects Claude Sonnet 5.5 for Claude Code and GPT-6.1 Terra for Codex, not Fable 5.2 or Astra. At a 40% weight on price, neither flagship's lead covers its cost for a general-purpose default, which is the routing argument of this section turned into a rule: the flagships earn their place on the share of work where their lead decides the outcome.
16. Verdict and Decision Checklist
On the evidence available on November 22, 2026, Claude Fable 5.2 is the stronger model and GPT-6.2 Astra is the more efficient one, and the identical $8 and $40 price hides that difference rather than resolving it. Fable leads the Artificial Analysis Intelligence Index (65 against 62), the Vals Index (first against eighth) and every independent coding-agent measurement that tests both, and it is faster per token, flat-priced across a million tokens and half the price on cached reads. Astra finishes general knowledge work for roughly a quarter to a third of Fable's cost at matched quality, leads on finished professional deliverables, terminal science and interactive 3D, and offers zero data retention, background discounts and an Ultrafast tier that Fable does not.
The structural conclusion is the one that will outlast these specific numbers. When two labs charge the same per-token price, the price of a finished task is set by token efficiency, cache economics and context length, and those depend on the work. That makes "which model?" an empirical question about your own workload, measured in cost per finished task at each effort level, and it makes the ability to change the answer cheaply worth more than either model's lead this month. For the previous round of this same comparison, our guide to GPT-6 Astra against Fable 5.1 shows how much has moved since September.
Use this checklist to decide, in order:
- What does a finished task look like? A merged change or a completed long-running job points to Fable; a document, model, deck or analysis a person will use as is points to Astra.
- How long are single requests? If many exceed 272,000 input tokens, price them on Fable first, because Astra's long-context rates apply to the whole request.
- What do your contracts say about retention? If zero data retention is required, Astra (with OpenAI's approval) is available today and Fable needs Anthropic's express authorization.
- Where must the model run? Fable is on AWS, Google Cloud and Microsoft Foundry now; Astra is on OpenAI's API, with Google Cloud in private preview.
- Which effort level actually pays? Sweep low to max on both models in your own harness. Start Fable at high and Astra at medium, and treat Fable's max as a ceiling measurement, not a production setting.
- How often does each model refuse or stop early on your tasks? Configure Fable's fallback, write Astra's blocker-report instruction yourself, and verify every "done" externally.
- Who pays for the tokens? If your customers hold Claude Platform commitments or ChatGPT plans, linked billing or Sign in with ChatGPT can move the flagship's cost off your margin.
- What happens in the next six weeks? Gemini 4 Neon belongs in your coding evaluation, Carbon doubles on December 1, older OpenAI models shut down on December 11, and Ultrafast doubles in price on March 1.
- Can you switch in an afternoon? If not, fix that before you optimize anything else, and our guide to pricing an AI product above token costs covers protecting the margin while you do.
What this article rests on
Every model figure linked 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.
- 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.
- Claude Opus 5.5 (Anthropic): $4 in and $20 out per million tokens, cached input $0.20, a 1M token window, listed 22 September 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.
- 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.
- Gemini 4 Neon (Google): $3 in and $15 out per million tokens, cached input $0.15, a 1M token window, listed 18 November 2026.
- Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
In this topic: AI models
- Claude Fable 5.2 vs Gemini 4 Carbon: Which to Build On
- Gemini 2.5 Flash and Pro Deprecation: Migrate by Dec 1
- Anthropic S-1: What Claude Builders Should Change (2026)
- OpenAI Dots vs Gemini Agent vs Grok Bot: Which to Hire 2026
- Claude Sonnet 5.5 vs GPT-6.1 Sol: Which to Build On (2026)
- Gemini 4 Argon Pricing: $2/$10 Now, Doubles Dec 1 (2026)
- Claude Haiku 5.5: 75% Cheaper Than 4.5, Takes On GPT-6 Luna
- Personal Sovereign AI: Own Your AI in 2026
Which AI model should you build on? Every guide on it
Data behind this topic: AI model prices, context windows and release dates.