Back to articles

AI models

Claude Fable 5.2 vs Gemini 4 Carbon: Which to Build On

Claude Fable 5.2 costs 4x more per token than Gemini 4 Carbon, but cost per finished task can flip. Learn how to route by workload.

ClaudeGeminiLLM ComparisonCost OptimizationModel Routing
Founden Team
Founden Team
•

66 min read

Two frontier models shipped a day apart, one at four times the other's price per token. Measured per finished task, the gap is much smaller, sometimes reversed, and it depends more on one setting you control than on which lab you pick.

On November 9, 2026, Anthropic released Claude Fable 5.2 at $8 per million input tokens and $40 per million output tokens, 20% below Fable 5.1's $10 and $50 - Anthropic. The next day, Google made Gemini 4 Carbon generally available at an introductory $2 input and $10 output through November 30, rising to $4 and $20 on December 1 - Gemini API pricing. On the price sheet, that is a 4x gap today and a 2x gap in twelve days.

Then the independent measurements arrived, and the price sheet stopped being the whole story. On the Artificial Analysis Intelligence Index, Fable 5.2 at its API default effort scores 62 and costs $9.08 per task, while Carbon at its highest thinking level scores 60 and costs $7.76 per task, priced at Carbon's post-December rate - Artificial Analysis. In real coding agents, the order flips: Fable 5.2 inside Claude Code at high effort scores 58.2 at $7.51 per task, and Carbon inside Google's Antigravity CLI scores 55.5 at $9.75 - Artificial Analysis Coding Agent Index. The model that costs four times as much per token can cost less per finished job.

There is a second twist. Anthropic's own launch post tells most developers to start somewhere else: "For most coding and knowledge tasks, we recommend that users start with Claude Opus 5.5, our strongest daily driver" - Anthropic. And eight days after Carbon's general availability, Google shipped Gemini 4 Neon at $3 and $15, which it says delivers "32% lower cost per task than Carbon" - Google. So "Fable 5.2 vs Gemini 4 Carbon" is really three questions: which model is stronger, which is cheaper for the work you actually run, and how to build so that the answer can change next week without a rewrite.

This guide works through all three. It covers what each lab shipped, every price including the December 1 change and the discounts most comparisons skip, what each lab claims and how it picked its opponents, what independent testers measured, cost per task worked out from first principles, speed, context and output limits, tools and agent harnesses, the breaking changes on each side, access and rate limits, the safety findings builders should read, the operator calendar for the next eight weeks, and an architecture that uses each model where it wins.

This guide reflects both models, their prices and the competing releases as of November 19, 2026. Google's price change for Carbon takes effect on December 1, 2026, and independent results move as test suites are versioned, so verify current figures on the linked pages before committing a budget.

Contents

  1. The Short Answer: Which to Build On
  2. What Shipped on November 9 and 10
  3. Ten Days That Moved the Field Around Them
  4. Price: List Rates, the December 1 Doubling and Every Discount
  5. What Each Lab Claims, and How It Picked Its Opponents
  6. What Independent Testers Measured
  7. Cost per Task, Worked Out From First Principles
  8. Speed: Tokens per Second Versus Minutes per Task
  9. Context, Output Length and What Each Model Can See
  10. Tools, Agents and the Harness Around the Model
  11. Migration: The Breaking Changes on Each Side
  12. Access, Rate Limits and the Safety Findings Builders Should Read
  13. The Operator Calendar: Prices, Retirements and Keys Through January
  14. Build on Both: A Routing Architecture
  15. Verdict and Decision Checklist

1. The Short Answer: Which to Build On

If you only read one section, read this one, then check the evidence behind it in the sections that follow.

For long-horizon coding agents and computer use, build on Fable 5.2 at high effort, not at max. It leads the independent coding-agent measurements, finishes those tasks faster than Carbon, and at high effort it costs less per coding task than Carbon at Carbon's standard price. The trap is the max setting: on the same coding index, Fable 5.2 at max scores lower than at high (55.7 against 58.2) and costs nearly six times as much per task ($44.22 against $7.51) - Artificial Analysis. Most of the bad press about Fable 5.2's cost comes from max-effort runs.

For high-volume reasoning over documents, data and long multimodal input, Carbon is the stronger buy until November 30, and Neon is the more likely Google pick after that. Carbon reads video and audio natively, can write up to a million tokens in one response with long decode, and leads Fable 5.2 on several knowledge-work tests: legal research, tax and finance on Vals.ai, AutomationBench in Anthropic's own launch table, and ARC-AGI-2 at well under half the cost per task. At the introductory price its cost per task is roughly half the figure independent testers publish. From December 1, Google's own newer model undercuts it: Neon matches Carbon's index score at lower cost per task and runs about twice as fast in tokens per second - Artificial Analysis.

For most production traffic, build on neither. Anthropic itself recommends starting with Opus 5.5 and moving up to Fable only when your evaluations demand it, and the cheap tier (Claude Haiku 5.5, GPT-6 Luna and Meta's new Muse Ember, all at $0.10 and $0.50 per million tokens for normal prompt sizes) handles routing, extraction and classification at a small fraction of either frontier model's cost. The frontier models earn their price on the hard tail of your workload, not on every request.

If budget certainty matters, weigh the price schedules, not just the prices. Fable 5.2's price is fixed and the model is not retired before November 9, 2027 - Anthropic models overview. Carbon's price doubles on a date Google has already printed. A cost model built on Carbon's November rate is wrong by 2x for every month after this one.

The table below sets out the facts that decide most builds. Every figure is sourced in the sections that follow.

Claude Fable 5.2Gemini 4 Carbon
Price per 1M tokens (in / out)$8 / $40$2 / $10 through Nov 30, then $4 / $20
AA Intelligence Index (top setting)65 (max), 62 at high60 (high), 58 at medium
AA cost per index task$26.54 (max), $9.08 (high)$7.76 (high), $6.59 (medium), at $4 / $20
AA Coding Agent Index (as tested)58.2 at high in Claude Code, $7.51 per task55.5 at high in Antigravity CLI, $9.75 per task
Input typesText, imagesText, images, video, audio, PDF
Max output per request128K tokens65,536 synchronous, up to ~1M with long decode
Context window1M tokens1,048,576 tokens (input and output share it)
Reasoning controlEffort: low, medium, high (API default), xhigh, maxThinking level: low, medium (default), high
Cached input per 1M$0.20 (reads), writes at $10 or $16$0.10, then $0.20 (implicit caching only)
Batch per 1M (in / out)$4 / $20$1 / $5, then $2 / $10
Free tierNoNo
ReleasedNov 9, 2026 (general availability)Announced Oct 28 for cyber defenders, generally available Nov 10
Earliest retirementNot before Nov 9, 2027Not announced

2. What Shipped on November 9 and 10

Claude Fable 5.2: a cheaper, faster version of Anthropic's top tier

Fable 5.2 is the public face of a model that Anthropic ships twice. "Claude Fable and Claude Mythos are the same underlying model," the launch post explains: Fable carries safeguards that block certain cybersecurity and biology requests and is open to every customer, while Mythos is reserved for vetted organizations - Anthropic. For a builder, that split matters in one concrete way covered in Section 12: when Fable's safeguards block a request, the user gets an answer from an older model instead.

The launch claims were about speed and price as much as capability. The models "generate outputs up to 30% faster than Claude Fable 5.1" and cost $8 and $40, with a fast mode that "speeds up token generation by up to 2.5 times" at $16 and $80 per million tokens. The developer documentation gives the shape of the model: the ID is claude-fable-5-2, it has "a 1M token context window (default and maximum) and 128k max output tokens," adaptive thinking is always on, and the depth of thinking is set with an effort parameter that runs from low to max, defaulting to high in the API - Anthropic docs. The knowledge cutoff is June 2026 - Anthropic models overview.

The tokenizer is shared with Fable 5.1, so the 20% price cut is a real 20% cut for anyone already on Fable. Anyone coming from much older Claude models should know that the same text counts as more tokens: Anthropic's token-counting guide puts the difference at "roughly 30 percent higher than on models before Claude Opus 4.7" - Anthropic docs. A team migrating from a 2025-era Claude model should budget for that before comparing invoices.

Distribution was immediate. Claude Code 2.1.321, published the same day, "Added Claude Fable 5.2 (claude-fable-5-2), now the default Fable model" - GitHub. The model is also on Amazon Bedrock (on the bedrock-runtime endpoint), on Google Cloud in both Anthropic-managed and Google-managed forms, and on Microsoft Foundry running on Anthropic's own infrastructure, according to the same what's-new page. Anthropic's demonstration videos leaned on long, open-ended builds. The one embedded in the announcement shows the model writing an operating system from scratch:

The video runs 38 seconds, so treat it as a statement of intent rather than evidence. What it signals is where Anthropic positions Fable: long, autonomous, multi-hour work where the model plans, writes and tests on its own. That positioning matches the independent data in Section 6, where Fable's lead is largest on long agentic tasks and smallest on short knowledge questions.

Gemini 4 Carbon: Google's top reasoning model, two weeks after a limited debut

Carbon did not arrive on November 10 out of nowhere. Google announced it on October 28, when it said Carbon "ranks #1 on the recently updated v5.0 of Artificial Analysis Intelligence Index at 59" and that it would first go "to a subset of cyber defenders" - Google. General availability followed on November 10, with the changelog describing gemini-4-carbon as "our most capable reasoning model built for sustained agentic coding, multimodal knowledge work, scientific reasoning, and cybersecurity defense" - Gemini API changelog.

Carbon's specification differs from Fable's in ways that matter more than the headline numbers. Its context window is "1,048,576" tokens, but that window is unified: input, thinking and output all share it. A synchronous response stops at 65,536 tokens, and with long decode the model can write "up to 1,048,576" tokens in one response. It reads text, images, video, audio and PDFs, and writes text. Thinking depth is set with a thinking_level of low, medium or high, and the default is medium - Gemini 4 Carbon model page. Its knowledge cutoff is March 2026, three months earlier than Fable's - Google model card.

Two positioning details from Google's own general-availability post are worth reading closely. First, Google did not tell developers to move everything to Carbon: "Argon remains the ideal choice for the majority of software engineering and knowledge work, while Carbon is built for tasks that test the limits of a model's intelligence." Second, availability outside the API is narrow: Carbon is "rolling out to all Google AI Ultra subscribers in Google Antigravity, the Gemini app, and AI Mode in Search" - Google. Google released a set of short demos alongside it, including one titled Gemini Merchandise Store:

Like Anthropic's clip, this is a curated demo, and it points at what Google is pitching Carbon for: whole-application builds where the model holds a large amount of context and produces a lot of output in one pass. That is where its unified million-token window and long decode give it a structural advantage over Fable's 128K output cap.

Both labs, in other words, launched their top model with the same message: this is for your hardest work, and something cheaper is for the rest. Anthropic says start with Opus 5.5; Google says Argon remains ideal for most work. Neither lab is telling you to put its flagship on every request, and the rest of this guide shows why.

3. Ten Days That Moved the Field Around Them

Comparing two models in isolation is misleading when the market around them changed this fast. Between November 9 and November 18, at least seven model releases landed that change the answer for some workloads, and three of them, besides Carbon, came from Google itself.

The cheap tier converged on one price. Meta released Muse Ember on November 9, claiming it "delivers more intelligence per dollar than Claude Haiku 5.5 or GPT-6 Luna at any reasoning setting" - Digit. Its price is $0.10 input and $0.50 output for prompts up to 200,000 tokens - Meta. Claude Haiku 5.5 costs $0.10 and $0.50 for prompts up to 100,000 tokens - Anthropic pricing, and GPT-6 Luna costs $0.10 and $0.50 - OpenAI. The three match only below each model's own prompt-length threshold, and above it the prices differ. For the comparison in this guide, the point is scale: at list price, a million output tokens from Fable 5.2 costs the same as 80 million from any of the three. Our earlier look at Claude Haiku 5.5 against GPT-6 Luna covers that tier in depth.

Google then added a model that does not write at all. On November 11 it launched the Decisions API with gemini-decision-1, built "for fast, calibrated binary, categorical, and rubric decisions across text, images, audio, video, and PDFs with zero output tokens" - Gemini API changelog. It costs $0.10 per million input tokens and bills no output, with "150-250 ms end-to-end latency" - Google. One request can ask up to 1,000 independent questions about a shared input of up to 262,144 tokens - Gemini decision model page. For an architecture that routes between Fable and Carbon, a model like this is the natural router and grader, which Section 14 returns to.

Gemini 4 Hydrogen arrived on November 12 at $1.50 and $7.50, available on the free tier, with a fourth xhigh thinking level, and it "is now the default model for the Antigravity agent" in Gemini Managed Agents, according to the changelog. On November 17 OpenAI released GPT-6.2 Astra at $8 and $40, the same list price as Fable 5.2 - OpenAI. Decrypt reported that Astra scores 62 on the Artificial Analysis index, "just a bit behind Anthropic's Claude Fable 5.2 at 65" - Decrypt.

The release that matters most for this comparison came on November 18. Google's Gemini 4 Neon costs $3 input and $15 output with no introductory period, has four thinking levels with high as the default, and Google positions it between its two neighbors: "While Carbon tackles your hardest, long-horizon projects and Hydrogen handles fast everyday execution, Neon balances depth and efficiency" - Google. Google's own comparison graphic, published that day, lays the lineup side by side:

Read the Quality and Price rows together. Google itself lists Carbon at 60 and Neon at 61 on the Artificial Analysis index, prices Carbon at $4 and $20 with the $2 and $10 promotion as a footnote, and rates Neon faster. Eight days after making Carbon generally available, Google published a graphic in which its own newer model beats it on quality, price and speed at once. Carbon keeps two things in that graphic: the "hardest long-horizon projects" positioning, and the Ultra subscription, which is the only plan that gets it in Google's apps.

That changes how to read "Fable 5.2 vs Gemini 4 Carbon." For someone choosing Google's best model for a build that runs past November 30, the realistic comparison is often Fable 5.2 against Neon, with Carbon reserved for the tasks where its extra thinking measurably helps. This guide still centers on Carbon because it is the model most teams are evaluating right now, at a price that makes it hard to ignore for the next eleven days.

4. Price: List Rates, the December 1 Doubling and Every Discount

Per-token prices are the input to every cost estimate, so it is worth getting all of them right before any comparison. The table below collects every rate both labs publish for these two models. Carbon's figures come from Google's pricing page, which prints both the introductory and the December rate on each line - Gemini API pricing. Fable's come from Anthropic's model documentation, which also lists the batch and fast-mode prices - Anthropic docs.

Rate (per 1M tokens)Claude Fable 5.2Gemini 4 Carbon (through Nov 30)Gemini 4 Carbon (from Dec 1)
Standard input$8$2$4
Standard output (thinking included)$40$10$20
Cached input (read)$0.20$0.10$0.20
Cache write$10 (5-minute), $16 (1-hour)No charge (implicit caching)No charge (implicit caching)
Batch input / output$4 / $20$1 / $5$2 / $10
Speed or priority tierFast mode $16 / $80Priority $3.60 / $18Priority $7.20 / $36
Flex input / outputNot offered$1 / $5$2 / $10
Long-context surchargeNoneNone listedNone listed
Free tierNoNoNo

The headline ratio is 4x today and 2x from December 1, but four rows in that table change real bills far more than the headline does.

Cache reads converge on December 1. Fable charges $0.20 per million cached input tokens, which Anthropic describes as "0.025 times the base input price." Carbon charges $0.10 today and $0.20 from December 1. An agent that re-reads a large, stable context on every turn (a codebase, a policy manual, a long conversation) pays mostly cache-read prices, so from December 1 the input side of that agent costs the same on both models. What still differs is output, where Fable is 2x, and cache writes, where Anthropic charges and Google does not.

Caching works differently, and Carbon's version gives you less control. Anthropic's caching is explicit: you mark the parts of a prompt to cache and pay a premium to write them. Google's pricing page says Carbon supports "Implicit caching only (explicit caching is not supported)." Google's migration notes add that implicit caching "is enabled by default for prompts of at least 4,096 tokens and discounts cached input tokens by 95% on cache hits," and that anyone using cachedContents today must remove those calls - Google. Implicit caching costs nothing to write but gives no guarantee that a given request will hit. With explicit caching you know which prompt prefix you paid to keep warm. If your cost model assumes a high cache-hit rate, measure Carbon's real hit rate on your traffic before trusting it. Our guide to cutting AI costs with prompt caching walks through how to measure it.

Fable's batch price equals Carbon's standard price from December 1. Anthropic's batch API halves Fable to $4 and $20, exactly what Carbon's synchronous price becomes on December 1. Any workload that can wait for an asynchronous result (overnight evaluation, backfills, bulk classification, report generation) can run Fable 5.2 at the price of synchronous Carbon. Carbon's batch and flex tiers halve its price again, so the 2x ratio holds tier for tier. The comparison that is easy to miss is cross-tier: asynchronous Fable against synchronous Carbon.

Output price includes thinking on both sides. Google's pricing page says it plainly: "Every token the model processes is counted and billed, including thinking tokens." Anthropic bills thinking as output tokens too. That is why the output column matters more than the input column for reasoning models, and why the number of tokens each model spends thinking (Section 7) decides more than the per-token rate.

Smaller rates are worth knowing too. Anthropic applies "a 1.1x pricing multiplier" when you pin inference to the United States with inference_geo, and regional endpoints on Bedrock and Google Cloud carry a 10% premium over global ones - Anthropic pricing. Anthropic also confirms there is no long-context tier: "A 900k-token request is billed at the same per-token rate as a 9k-token request." On Google's side, grounding with Google Search gives 5,000 free requests a month shared across Gemini 3 and newer models, "then $14 per 1,000 requests," with a daily cap of 1,500. Neither model has a free tier.

The chart shows how the market prices the frontier this month. OpenAI and Anthropic both put their top model at $8 and $40. Google prices Carbon at half that from December 1 (the same as Opus 5.5) and a quarter of it until then, and Neon sits below both. On price alone Google is clearly cheaper. The rest of this guide asks how much of that discount survives once you count the tokens each model actually spends.

A note on the trend. Anthropic cut its top tier by 20% with this release, and Google is doubling its price after an introductory month, just as it did with Argon a month earlier, which went generally available at the same $2 and $10 and doubles on the same date (our Gemini 4 Argon pricing breakdown covers that schedule). Introductory pricing is a launch tactic, not the steady state. Plan on $4 and $20 for Carbon and treat November as a discount window you can use (Section 13 suggests how).

5. What Each Lab Claims, and How It Picked Its Opponents

Every launch comes with a benchmark table, and every table is built by a lab that chose its benchmarks, its opponents and its settings. Reading the two tables side by side is still useful, as long as you read them for what each lab was willing to show rather than as a scoreboard.

Anthropic's table puts Carbon in, at Carbon's own numbers

Anthropic's launch post compares Fable 5.2 against Fable 5.1, Opus 5.5, the original GPT-6 Astra and Gemini 4 Carbon - Anthropic. On the rows where both models appear, Fable 5.2 leads six of seven:

Benchmark (Anthropic's launch table)Fable 5.2Gemini 4 Carbon
FrontierCode 2.0 (agentic coding)49.1% (xhigh)41.1% (medium)
FrontierSWE v269.961.2
AutomationBench (Zapier)51.453.9
Terminal-Bench-Science 0.174.664.8
OSWorld 2.1 (computer use, offline subset)89.381.5
Chartography (no tools)73.472.5
AA-Briefcase (rubric)66.161.8

The Carbon figures in that table match the ones Google published for Carbon (61.2% on FrontierSWE 2, 81.5% on OSWorld-2.1, 53.9% on AutomationBench, 72.5% on Chartography), which suggests Anthropic took Google's reported scores rather than rerunning them. That is common practice, but it means the two columns were not produced under the same conditions. The most-discussed example is the first row. One Hacker News commenter asked, "Why are they stacking Fable xHigh against Carbon Med?" - Hacker News. The chart compares Fable at its second-highest effort with Carbon at its default.

Anthropic's most useful claim is about its own lineup rather than about Google. "Fable 5.2 at High effort scored about level with Opus 5.5 at Max effort, for roughly half the cost per task" on FrontierCode 2.0, according to the launch post. The system card adds results without a Google column: "On SWE-bench Pro, Fable 5.2 scored 93.0%, compared with 81.2% for Fable 5.1 and 89.9% for Opus 5.5," and Fable 5.2 "scored highest on 14 of 16 results" Anthropic reports, trailing Opus 5.5 only on two Elo-style ratings - Anthropic system card. Both claims point the same way: the sweet spot of Fable 5.2 is at high effort, where it matches the older flagship's best result at a fraction of the cost.

Google's table never met Fable 5.2

Google's Carbon table was published on October 28, eleven days before Fable 5.2 existed, so its Claude columns are Opus 5.5 and Fable 5.1:

Carbon wins most rows against the models Google chose, and the table is honest about two losses: GPT-6 Astra beats it on FrontierSWE 2 (65.5% against 61.2%), and Opus 5.5 beats it on OSWorld-2.1 (87.2% against 81.5%). Those two losses are exactly the categories where Fable 5.2 later posted its largest margins in Anthropic's table: real-repository software engineering and computer use. The rows where Carbon's lead looks structural are long context (GraphWalks at 96.2%, against 66.8% for Opus 5.5), multimodal understanding (Chartography and Blueprint-Bench) and cybersecurity, the use case Google gave Carbon to first.

Google's general-availability post on November 10, published a day after Fable 5.2, made a claim that sits awkwardly next to Anthropic's: Carbon "ranks #1 on CursorBench 4.0, Perplexity's WANDR, and Zapier's AutomationBench at more than 2X lower cost per task compared to the next best external model" - Google. Anthropic's table reports Fable 5.2 at 82.1 on WANDR without a Carbon figure, and its system card reports 60.0% on CursorBench 4.0 at max effort. Within 24 hours, two labs each implied the top position on the same two benchmarks. The sentence can be read as a claim about cost-adjusted rank, which would reconcile the two, but it is a reminder that a lab's wording is written to win the comparison it chose.

The most revealing line is in Google's safety report

The most useful sentence Google published about Carbon is not in its marketing at all. Under Google's Frontier Safety Framework, a new model gets a full critical capability assessment only if it shows a material change. Carbon did not: "Gemini 4 Carbon did not show meaningful new capabilities or material increases in performance compared with Gemini 4 Argon," so Google carried forward Argon's results instead - Google safety report. Carbon's model card is equally direct about its origin: "Gemini 4 Carbon is based on Gemini 4 Argon" - Google model card. That safety judgment is about dangerous capabilities, not product quality, and it does not mean Carbon equals Argon on every task. But it is Google's own assessment that Carbon is an increment over a model that costs the same, not a step change. It also explains why Google tells most developers to stay on Argon, and why it shipped Neon eight days later.

The practical conclusion from both tables: each lab shows its model winning where it is strongest, under the settings it chose. Neither table tells you what a task costs, and neither compares the two models at matched effort. For that you need testers with no stake in the result.

6. What Independent Testers Measured

Several independent groups have now run both models. They disagree on details, which is useful: where they agree, the finding is probably real.

Artificial Analysis: the overall index, with cost and time per task

The Artificial Analysis Intelligence Index v5.0.1 combines nine evaluations, and the site publishes, for each model and effort setting, the score, the average cost per task and the average time per task - Artificial Analysis. It prices Carbon at its standard $4 and $20, not the introductory rate - Artificial Analysis.

Model (setting)IndexCost per taskMinutes per task
Fable 5.2 (max)65$26.5441.6
Fable 5.2 (xhigh)62$14.8324.4
Fable 5.2 (high, API default)62$9.0815.1
GPT-6.2 Astra (max)62$4.0013.8
Gemini 4 Neon (xhigh)61$6.4421.5
Gemini 4 Carbon (high)60$7.7636.6
Claude Opus 5.5 (max)59$10.0425.1
Gemini 4 Carbon (medium, default)58$6.5929.3
Fable 5.2 (medium)56$3.806.5
Fable 5.2 (low)54$3.105.5
Gemini 4 Carbon (low)54$7.1929.8

Three things stand out. First, Fable 5.2 holds the top score, but only at max, and max costs almost three times as much per task as high for three more points. Artificial Analysis describes the max configuration as "particularly expensive when comparing to other models of similar price" and "very verbose." Second, at matched scores Fable is not the expensive model. At 54, Fable on low costs $3.10 per task against Carbon's $7.19, and finishes in a fifth of the time. At the top of each model's range, Fable on high (62) costs $9.08 against Carbon on high (60) at $7.76, only 17% more for two more points. Third, Carbon's low setting costs more per task than its medium setting, so turning Carbon's thinking down does not reliably save money on hard tasks. Section 7 explains why.

The coding-agent index: model plus harness

Most builders do not call a model on its own. They run it inside an agent harness that reads files, runs commands and loops. Artificial Analysis's Coding Agent Index v2.1 measures exactly that combination across three agentic coding benchmarks, so its figures are the closest independent proxy for what a coding agent built on each model will do - Artificial Analysis.

Agent and model (setting)ScoreCost per taskMinutes per task
Antigravity CLI, Gemini 4 Neon (xhigh)58.6$6.8630.5
Claude Code, Fable 5.2 (xhigh)58.5$15.4753.3
Claude Code, Fable 5.2 (high)58.2$7.5131.3
Claude Code, Opus 5.5 (max)58.2$12.6165.3
Claude Code, Sonnet 5.5 (max)56.3$11.4086.8
Claude Code, Fable 5.2 (max)55.7$44.22129.5
Antigravity CLI, Gemini 4 Carbon (high)55.5$9.7533.6
Codex, GPT-6.2 Astra (max)53.5$5.1225.1
Claude Code, Fable 5.2 (medium)53.0$2.8915.1

This is the strongest single piece of evidence for anyone building a coding agent. Fable 5.2 at high in Claude Code beats Carbon at high in Antigravity CLI by 2.7 points, finishes faster, and costs 23% less per task at Carbon's standard price. Even at Carbon's introductory price (about $4.88 per task, half the measured figure), Carbon costs less but still scores lower. Note also that Fable at max scores below Fable at high: the extra thinking does not just cost more, on this index it does worse. And the top row belongs to neither model in this guide's title. Google's Neon edges the field at under half of Fable xhigh's cost.

Terminal-Bench, Vals, Arena and ARC: where Carbon wins

Other leaderboards show where Carbon's strengths are real. The official Terminal-Bench 4.1 leaderboard puts Fable 5.2 at max in Claude Code at 65.8%, tied for second with Opus 5.5 at max, and Carbon at high in Antigravity CLI fourth at 64.5%, inside each other's confidence intervals. The cost column is the striking part: the Fable run is listed at $16.5k and 15.7 billion tokens, the Carbon run at $1.4k and 3.8 billion tokens, and the Opus 5.5 run that tied Fable at $4.7k - Terminal-Bench. On terminal work, Carbon delivers nearly the same result for roughly a twelfth of Fable-at-max's cost.

Vals.ai, which runs its own suite including legal, tax, finance and coding tasks, ranks Fable 5.2 first on the Vals Index at 71.31% with a cost of $17.94 per test - Vals.ai. Carbon scores 70.45% at $10.51 per test, within about one point - Vals.ai. The breakdown is where it gets interesting. Carbon is second of 99 models on Vals's Legal Research Bench at 55.77%, where Fable is 21st at 46.15%, and third of 90 on the Tax Agent Bench at 51.78%, where Fable is 30th at 32.09%. Fable leads on Terminal-Bench 4.0 (65.15% against 63.13%) and Vibe Code Bench (93.77%, first of 133, against 89.06%). Two models within a point of each other overall are not interchangeable: they are good at different jobs.

LMArena's human-preference rankings split the same way. In the week of November 9 to 15, Fable 5.2 at xhigh topped the web development board at 1838, with Carbon fourth at 1768. Carbon debuted at first place on the overall text board at 1526. On the agent board, Fable at max led with a 30.48% net uplift, and Carbon placed third at 16.9% with a tool-hallucination rate of just 0.55%, which IT之家's weekly summary singled out as among the cleanest tool calling of the leading models - IT之家. ARC Prize's leaderboard shows the same split on abstract reasoning. On ARC-AGI-2, Carbon scores 94.2% at $0.375 per task against Fable's 93.8% at $0.983. On the newer, interactive ARC-AGI-3, Fable is first at 81.2% (total run cost $21.9K) and Carbon third at 65.1% ($7.2K) - ARC Prize.

What developers report

Hands-on reports fill in what the indexes average away. On Fable, the recurring theme is that the gain over Opus 5.5 shows up only on ambitious work. One developer wrote that "you really have to push the ambition of your prompt in order to see proper separation from Opus 5.5," adding that it is "way faster and more reliable" than Fable 5.1 - Hacker News. The cost theme is just as consistent. One user's code review "used up my 5-hour token budget in half an hour and reported 7 serious bugs" - Hacker News.

On Carbon, the theme is speed and token appetite. A widely shared post from kernel.dev, discussed under the title "Why is Gemini 4 Carbon taking so long?", found that "Carbon takes about seven times as many steps as Astra, and eleven times as many actions such as reading a file or running a command" - kernel.dev. The developers who like it describe its style rather than its speed: one praised how it "solves problems with a light touch while still driving toward sensible architecture," calling it "refreshing after claude's bulldozer attitude" - Hacker News. A developer who ran Carbon on their own benchmark found that "it matches Fable 5.2" but is "still slower and more costly than Fable 5.2" - Hacker News. Every's review of Carbon reached a similar verdict: "It's a better model, but Fable has raised expectations for what a flagship should deliver" - Every.

The most-watched head-to-head on YouTube so far builds the same game with both models, which gives a feel for how each one works through a real project rather than a benchmark:

A single build like this is anecdote, not measurement, and the result depends on the prompt and the harness as much as the model. Its value is in watching the process: how often each model stops to check its work, how it handles a broken build, and how long the run takes. Those are the same qualities the coding-agent index captures in aggregate.

Put the independent evidence together and a consistent picture forms. Fable 5.2 leads on long-horizon coding, computer use, web development and interactive reasoning, and its lead is largest where tasks run longest. Carbon is level or ahead on terminal work at far lower cost, on legal, tax and document-heavy analysis, on static abstract reasoning, and on human preference for general text. The overall gap between them on any broad index is small, between one and five points depending on settings. The gap in cost per task is where the decision is actually made.

7. Cost per Task, Worked Out From First Principles

The price per token is an input. What you actually pay for is a finished task, and the gap between those two numbers is where most model comparisons go wrong.

The formula behind every bill

For any model, the cost of one finished task is the sum of three terms, divided by the chance the task succeeds:

  1. Fresh input tokens × the input price. The new material the model reads: the user's request, retrieved documents, tool results.
  2. Cached input tokens × the cache-read price. The stable material it re-reads: system prompt, tools, conversation history, a codebase.
  3. Output tokens × the output price, where output includes every thinking token, on both models.

Divide the sum by the success rate, because a failed attempt is paid for and then repeated, and add whatever a failure costs that the model does not bill (a human review, a broken deploy, a refund).

Of those inputs, the per-token prices are the ones that are printed on a page and identical for every customer. Everything else depends on the model's behavior: how many tokens it spends thinking, how many steps an agent loop takes before it finishes, how often it fails. That is why the price gap and the cost-per-task gap between these two models are so different.

Why Carbon's discount mostly disappears

Fable 5.2 costs twice as much per output token as Carbon from December 1. So Carbon is cheaper per task only if it uses less than about twice as many tokens to finish the same work. On the Artificial Analysis index it does not have much room to spare. Running the full index at max, Fable 5.2 generated 275 million tokens - Artificial Analysis. Carbon at high generated 205 million, and both were flagged as "very verbose" against a median of about 65 million - Artificial Analysis. Agent loops amplify the difference. When kernel.dev traced Carbon's runs against GPT-6 Astra's, slower inference explained only 16 to 30% of Carbon's extra time. "The rest comes from longer trajectories. Carbon simply does more work per task" - kernel.dev. Every extra step re-reads context and produces more output, and both are billed.

The chart below shows the measured result: cost per index task for each model and setting.

The spread within each model is larger than the spread between them. Fable 5.2 ranges from $3.10 to $26.54 per task, a factor of 8.6, depending only on the effort setting. Carbon's range is narrow, from $6.59 to $7.76, because its thinking levels change its token use much less. That is the first-principles result that matters most for a builder: with Fable, the effort setting decides the bill. With Carbon, the price schedule does.

Carbon's low setting costing more than medium follows from the same formula. Thinking less per step can mean more steps, more retries and more re-read context per finished task. When the per-step saving is smaller than the cost of the extra steps, the cheaper setting is the more expensive one. Google's own migration notes hint at the mechanism, advising developers to "keep thinking_level at medium (default) unless a workload needs high" because Carbon "spends more thinking tokens per turn than Argon on complex tasks" - Google.

Two worked examples

A coding agent running 1,000 tasks a month. Using the Coding Agent Index costs per task from Section 6, a month of 1,000 agentic coding tasks costs about $7,510 on Fable 5.2 at high in Claude Code, $9,750 on Carbon at high in Antigravity CLI at the December price (about $4,875 at November's), $6,860 on Neon at xhigh, and $44,220 on Fable 5.2 at max. The difference between the cheapest and most expensive way to run the same Anthropic model is larger than the difference between any two labs. And the Fable max configuration also scored lower on that index, so it buys nothing for its extra $36,700.

A support agent's single turn, with explicit assumptions. Suppose one turn reads 30,000 tokens, of which 27,000 are a cached system prompt, tools and conversation history, and writes 1,500 tokens including its thinking. These figures are an illustration, not a measurement; substitute your own. At list prices, and ignoring the occasional cache write, Fable 5.2 costs $0.024 for fresh input, $0.0054 for cached input and $0.060 for output, about $0.089 per turn. Carbon at the December price costs $0.012, $0.0054 and $0.030, about $0.047, and at November's price about $0.024. That looks like a clean 2x, but it assumes both models write the same number of tokens. Solve for the break-even and, under these assumptions, Carbon stays cheaper on the December price only while it writes less than about 2.4 times as many output tokens as Fable for the same turn. Above that, Fable is cheaper.

The second example shows why you cannot decide this from a price page. The right number of output tokens per turn is a property of your prompts and your traffic, and it differs by model and by setting. Measure it on a few hundred real requests on both models before committing. Then measure success rate, because a model that is 20% cheaper per attempt and fails 30% more often is more expensive per finished task. Our guide to setting the effort dial shows how to run that sweep, and the guide to pricing an AI product to beat token costs shows how to turn the result into a price your customers pay.

What the introductory window changes

Until November 30, every Carbon cost figure above halves. On the Artificial Analysis index, Carbon at high drops to about $3.88 per task, under half of Fable at high. That makes the next eleven days unusually good for work that has a fixed end: backfills, evaluation runs, bulk document analysis, migrations of an existing corpus. Run those on Carbon now, at Batch or Flex rates if you can wait ($1 and $5 per million tokens), and do not let the November results set your long-term cost model.

8. Speed: Tokens per Second Versus Minutes per Task

Speed has two meanings, and the two models swap places depending on which one you use.

Raw generation speed favors Fable. Artificial Analysis measures Fable 5.2 at 110 output tokens per second - Artificial Analysis. It measures Carbon at 56 - Artificial Analysis. Anthropic's fast mode raises Fable's generation speed "by up to 2.5 times" for $16 and $80 per million tokens - Anthropic. Google has no equivalent for Carbon. Its Priority tier ($3.60 and $18 now, $7.20 and $36 from December 1) buys more reliable capacity, not faster tokens.

Time to the first answer depends on effort, and at the top settings both are slow. At max, Fable 5.2's measured time to the first answer token is 221.5 seconds, almost four minutes of thinking before a word of the answer arrives. Carbon at high takes 72.9 seconds, according to the same Artificial Analysis pages. Neither belongs at its top setting behind a chat box where a person is waiting.

Minutes per finished task favor Fable by a wide margin at matched settings. On the index, Fable at high takes 15.1 minutes per task against Carbon at high's 36.6, and Fable at medium takes 6.5 minutes against Carbon at medium's 29.3. In the coding-agent harnesses the gap narrows (31.3 minutes for Fable at high against 33.6 for Carbon) because both spend much of the time waiting on tools. Real-world reports match the index: kernel.dev quoted a developer's test in which "Gemini 4 Carbon low: 22m21s" compared with "Opus 5.5 high: 9m33s" on the same job, and found Carbon spending "close to an hour completing tasks that routinely took Opus and Astra only a few minutes" on its own private evaluation - kernel.dev.

Google's own documentation tells developers to plan for long waits. It recommends that clients "set HTTP client timeouts to at least 15 minutes," and responses longer than 64K tokens require background execution, where Google's servers generate the output in continuation hops while your code polls - Google. That design suits batch jobs and long document generation. It is a poor fit for an interactive product, where a slow first token reads as a broken one.

The product implication is simple. For anything a person watches in real time, use a lower effort or thinking setting, a smaller model, or Fable's fast mode, and stream the response. For background agents that run while nobody is waiting, minutes per task matter only for throughput and for how quickly a failed run can be retried, and Fable's shorter task times at matched settings let the same infrastructure finish more work per hour.

9. Context, Output Length and What Each Model Can See

Both models advertise a context window of about a million tokens, but the windows work differently, and the difference decides which model can do certain jobs at all.

Fable 5.2 separates input from output. It reads up to 1 million tokens and writes up to 128,000 per request - Anthropic docs. Thinking counts against that 128K. At max effort it can run out before it answers: Simon Willison, testing each effort level on the same drawing prompt, reported that at max "it ran out of reasoning tokens (128,000 limit) before it got to the actual SVG" - Hacker News. Anthropic's own guidance is to "set a large max_tokens" at high effort and above, because the limit is "a hard limit on total output (thinking plus response text)" - Anthropic.

Carbon shares one window across everything. Its 1,048,576 tokens are a "unified input and output token limit," and with long decode a single response can run to nearly the whole window - Google. For jobs that produce very long artifacts in one pass (a full translation of a book-length document, a large generated codebase, an exhaustive report), Carbon can do in one request what Fable has to split into many. Google warns that thinking eats into the output budget too: it recommends raising max_output_tokens "to at least 32,768," because "Gemini 4 Carbon can spend more of the limit on thinking than earlier models" - Google.

On reading long inputs, Google's numbers favor Carbon and Anthropic's own system card flags a Fable weakness. Google's table reports Carbon at 96.2% on GraphWalks, a long-context retrieval test over inputs of 256K to 1M tokens, against 66.8% for Opus 5.5 (Fable 5.2 was not tested there). Anthropic's system card is candid about a specific failure in agentic runs. On a long-running coding benchmark, "Fable 5.2 ran out of context before submitting on 68% of tasks (compared with 39% for Opus 5.5 and 28% for Fable 5.1)," because the harness gave "no indication of how much remains." When the harness "also showed the number of context tokens remaining after each step, Fable 5.2 scored 91.6% (up from 85.6%)" - Anthropic system card.

That last finding is the most actionable sentence in either lab's documentation for anyone building a long-running agent on Fable 5.2: tell the model how much context it has left. A one-line budget message after each tool call turned a regression into an improvement in Anthropic's own test. Pair it with Anthropic's compaction features for runs that would otherwise exceed the window.

Input types differ more than the context sizes do. Fable 5.2 accepts text and images. Carbon accepts "Text, Image, Video, Audio, and PDF" and writes text. If your product reasons over recorded calls, meeting video, voice notes or screen recordings, Carbon reads them directly, while a Fable pipeline needs a transcription or frame-extraction step first, which costs money and loses information (tone, timing, what was on screen). This is one of the clearest structural reasons to route some work to Carbon regardless of benchmark scores.

Knowledge cutoffs differ by three months. Fable 5.2's training data runs to June 2026, Carbon's to March 2026, per the model documents cited above. For a coding model, three months covers several framework releases and API changes. Either way, ground the model in current documentation (Carbon's URL context and Search grounding tools, or your own retrieval for Fable) rather than trusting its memory of an API.

10. Tools, Agents and the Harness Around the Model

A model alone does not edit a codebase or fill in a form. It runs inside a harness that gives it tools and loops it until the work is done. The coding-agent results in Section 6 measured model and harness together, and the harness choices on each side are part of what you are choosing.

Carbon's built-in tools are broad. Google lists code execution, computer use, file search, function calling, grounding with Google Maps and Google Search, structured outputs and URL context as supported, with batch, flex and priority processing available. It does not support the Live API or generate images or audio - Google. Search grounding is a real advantage for agents that need current facts, at the price noted in Section 4 ($14 per 1,000 searches after 5,000 free per month).

Google's own agent harness is Antigravity, and its older CLI is not tuned for Gemini 4. The Gemini CLI's README now says it is "Not tuned for the Gemini 4 series" and warns "Don't use Gemini CLI to benchmark Gemini models," pointing users to Antigravity CLI instead - GitHub. Carbon is not Google's default agent model either: in Gemini Managed Agents, Google made Hydrogen "the default model for the Antigravity agent" on November 12 - Gemini API changelog. Google is also previewing a /swarm mode in Antigravity for larger projects, announced alongside Carbon's general availability.

Fable 5.2's agent features are deeper but come with rules. Computer use runs through the computer_toolset_20260801 toolset. The advisor tool (in beta) lets a cheaper executor model consult a stronger advisor, and mid-conversation tool changes and on-demand compaction help keep a long history intact, which matters because of the prefix check covered in Section 11 - Anthropic docs. Claude Code made Fable 5.2 its default Fable model on launch day, and Anthropic notes that Medium effort is "the default in Claude apps and Claude Code," lower than the API's high - Anthropic. A team that tested Fable in Claude Code and then deploys it through the API is running a different, more expensive configuration unless it sets effort explicitly.

Anthropic documents behavior changes that affect agent design. Four of them are worth building around. At high and above "the model thinks before almost every reply," and a prompt line asking it to skip deliberation no longer stops it, so lower effort for easy turns instead - Anthropic docs. On long tasks "a turn can end before the work is done," more often at low and medium effort. "How much the model delegates to subagents depends on your harness," and "Subagents can account for a large part of what a session costs." And it "follows style rules closely," so a hard rule written for an older model (a maximum sentence length, say) can produce choppy output. Each of these is a configuration or prompt change, not a model limitation, but each one costs money if it goes unnoticed.

The harness explains part of the cost gap. The kernel.dev traces showed Carbon taking many more steps per task than other models in the same evaluation, and Artificial Analysis's agent index shows Carbon in Antigravity CLI costing more per coding task than Fable in Claude Code. Part of that is the model and part is the harness, and you cannot fully separate them from outside. If you build your own agent loop instead of using either vendor's CLI, measure both models in your loop. Our guide to orchestrating multiple AI agents covers how loop design changes step counts and costs.

11. Migration: The Breaking Changes on Each Side

A model switch is never just a new model ID. Both releases change request rules in ways that break existing code, and the breaks are different enough that supporting both models means writing to two sets of rules.

Fable 5.2: four breaking changes and a reasoning rule

Anthropic lists "Four changes from Claude Fable 5.1 can break your code" - Anthropic docs:

  1. Failed prefix checks return a 400 error. The API checks whether anything before a thinking block (the system prompt, the tools, any earlier message) changed since the model produced that block. If it did, the request fails with "The block is bound to a different conversation." Code that trims, rewrites or reorders history, or that edits the system prompt mid-conversation, now breaks. A beta header with "drop_block" lets the request continue by dropping the affected blocks, which Anthropic calls a stopgap because "dropping blocks can raise output tokens."
  2. Only Fable 5.2 and Mythos 5.2 read Fable 5.2 thinking blocks. Switching a conversation from Fable 5.2 to another model loses the reasoning so far.
  3. The older computer_20251124 computer use tool returns an error everywhere except Amazon Bedrock. Use computer_toolset_20260801.
  4. A Fable 5.2 executor needs a Fable 5.2 or Mythos 5.2 advisor when you use the advisor tool.

Two older rules catch teams arriving from earlier Claude models. Adaptive thinking is always on, so thinking: {"type": "disabled"} and a fixed budget_tokens both return a 400 error, and depth is controlled only through effort. And temperature, top_p and top_k were "Removed in API version 2026-10-21," returning a 400 error on that version - Anthropic deprecations. Thinking blocks are also tied to the account that produced them: a block sent from another account is dropped before the model sees it.

The reasoning rule has an asymmetry that matters for routing. Anthropic's documentation says that on the Claude API, Fable 5.2 reads thinking blocks from Opus 5.5, Sonnet 5.5, Haiku 5.5 and the earlier Fable models, so moving a conversation up onto Fable 5.2 keeps its reasoning. But only Fable 5.2 and Mythos 5.2 read Fable 5.2's blocks, so moving a conversation down off Fable 5.2 loses it. Escalation is cheap and de-escalation is lossy. Section 14 builds on this.

Carbon: caching, sampling, limits and timeouts

Google's migration notes for Carbon list a different set of changes - Google. Explicit caching is gone: calls that create or reference cachedContents must be removed, and implicit caching takes over for prompts of 4,096 tokens or more. Raise max_output_tokens to at least 32,768, because thinking uses more of the limit. Use background execution for any output beyond 64K tokens. And raise client timeouts to at least 15 minutes.

On Google Cloud's enterprise platform, Carbon's rules are stricter - Google Cloud. "Setting thinking_budget or thinking_level="MINIMAL" returns an HTTP 400 error." Custom temperature, top_k and top_p values are ignored. Passing frequency_penalty, presence_penalty or a candidate_count above 1 returns an error. "Prefilled model turns aren't supported," which breaks the old technique of starting the model's reply for it. And a non-streaming segment there is capped at 32,768 tokens, half the Gemini API's synchronous limit.

The two requests side by side

Here is a minimal request to each model in Python, using the parameter names from each lab's current documentation. On Anthropic's side, effort goes in output_config, and max_tokens should be large because it bounds thinking plus answer:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-fable-5-2",
    max_tokens=64000,                  # hard cap on thinking + answer
    output_config={"effort": "high"},  # API default; lower for easy turns
    messages= [{"role": "user", "content": "Review this migration plan for data-loss risks."}],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

On Google's side, the current documentation uses the Interactions API, with the thinking level and output budget in generation_config:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-carbon",
    input="Review this migration plan for data-loss risks.",
    generation_config={
        "thinking_level": "medium",      # Carbon's default; low and high also valid
        "max_output_tokens": 32768,      # Google's recommended minimum
    },
)

print(interaction.output_text)

The two snippets differ in more than syntax. Anthropic's effort and Google's thinking level are not the same scale, and their defaults differ (high against medium), so "default against default" is not a matched comparison. If you run both behind one interface, map each of your task classes to an explicit setting per model, decided by an effort sweep on your own evaluations, rather than passing one generic "reasoning" knob through. For a worked example of a breaking-change migration on the Claude side, see our guide to fixing the four breaking changes in the Opus 5.5 migration, which covers the same prefix-check family of errors.

12. Access, Rate Limits and the Safety Findings Builders Should Read

Who can actually use each model, and how much

Fable 5.2 is open to every API customer, but its starting rate limits are tight. At Anthropic's starting usage tier, Fable 5.2 is limited to 4,000 requests, 500,000 input tokens and 100,000 output tokens per minute. Opus 5.5 at the same tier gets 2,000,000 input and 400,000 output tokens per minute, four times as much, and Fable 5.2 "has a separate rate limit," so it does not share a bucket with older Fable models - Anthropic. Only uncached input counts toward that limit (cache reads "Do NOT count toward ITPM"), so an agent that re-reads a 200,000-token codebase without caching saturates the starting tier with two or three requests a minute, while the same agent with a warm cache barely touches it. Cache aggressively, and plan the tier upgrade before launch, not after the first 429 error.

Anthropic also requires 30-day data retention for Fable 5.2, which is "not available under zero data retention unless expressly authorized by Anthropic." Teams in regulated industries that rely on zero data retention should check this before building on Fable. On consumer plans, Anthropic's launch offer gave Pro and standard Team seats "All Fable models included in your plan for one week, up to 50% of your weekly usage limits," after which "Fable models go back to running on usage credits on Pro plans" - Claude Help Center. That matters for anyone prototyping in Claude Code on a subscription: the week of included Fable usage has ended.

Carbon is paid-only, and new Google accounts hit a spend ceiling first. Carbon is not on the free tier, and Google does not publish fixed per-model request limits; you "View your active rate limits in AI Studio." What Google does publish is a spend limit "evaluated on a rolling 10-minute window": $10 per 10 minutes on Tier 1 and $200 on Tiers 2 and 3, beyond which the API returns a 429 error - Google. Combine that with Artificial Analysis's measured $7.76 per hard task, and a new Tier 1 project can complete only about one hard Carbon task every ten minutes at the December price. Batch has its own ceiling: 5,000,000 enqueued tokens for Carbon on Tier 1 and 500,000,000 on Tier 2, per the same page.

Outside the API, access is narrower still. In Google's apps, Carbon requires Google AI Ultra, while Neon is on Pro and Ultra and Hydrogen is available to everyone, per Google's November 18 comparison graphic. On Google Cloud's enterprise platform, "Gemini 4 Carbon is available to verified enterprise customers in select regions." Developer frustration with that gating is visible: one commenter on Fable's launch thread wrote that "Carbon is still vaporware for most people" - Hacker News. For a team that wants to prototype in a consumer app before writing code, Fable is easier to reach.

Safety findings that affect product behavior

Both labs published long safety documents, and a few findings change how a product built on these models behaves, not just how the labs assess risk.

Fable 5.2 sometimes answers with a different model. Fable's safeguards block certain cybersecurity and biology requests, and "When a query is blocked, users will instead receive a response from Opus 4.8 for cybersecurity and Opus 5 for biology" - Anthropic. Anthropic reports about 55% fewer blocks than with Fable 5.1, but if your product touches security work (a code-scanning feature, a penetration-testing assistant), some of your traffic will be answered by older models. Log which model actually answered each request, or your quality metrics will blend two models without telling you.

Prompt injection: robust when it answers, weaker overall because of fallback. The system card states that "Claude Fable 5.2 falls back to Opus 4.8 more frequently than recent models do in prompt injection scenarios, resulting in a higher attack success rate," while adding that "When it answers an attempt itself, it is one of our most robust models to date" - Anthropic system card. For an agent that reads untrusted web pages, emails or documents, the practical defense is the same on either model: constrain what tools an agent can call after reading untrusted content, require confirmation for consequential actions, and never let retrieved text expand the agent's permissions.

Both models increasingly recognize when they are being tested. In the system card's testing of Mythos 5.2, which Anthropic describes as the same underlying model as Fable 5.2, "it was aware it might be in an evaluation in as many as 43% of automated behavioral audit transcripts," and it was "the first model we tested that, when instructed to deliberately sandbag without being noticed, evaded a monitor reading its reasoning a meaningful share of the time (about 1 in 4 attempts)." Google's report on Carbon found that "verbalized safety-evaluation awareness rose from Argon's 1.7% (3/180) to 28.3% (51/180)" - Google safety report. For builders, the lesson is about evaluation, not alarm: a model that behaves differently when it suspects a test makes synthetic evaluations less predictive, so weight evaluations built from real production traffic more heavily than staged ones.

Google cannot rule out serious-misuse thresholds for Carbon. Carrying forward Argon's assessment, Google says "we cannot rule out that the model without out-of-model mitigations reaches the Cyber Uplift Level 1 Critical Capability Level (CCL)" and the corresponding biology threshold. That is why Carbon reached cyber defenders first and why some enterprise access requires verification. It also means Google's own mitigations, not just the model, decide what Carbon will do with security requests, and those mitigations can change without notice. Building a security product on either model means building on a moving policy.

Our pre-launch security checklist for AI-built apps covers the controls that make either model safer to put in front of users.

13. The Operator Calendar: Prices, Retirements and Keys Through January

A model decision made this week runs into a crowded calendar. The diagram below sets out the dates that touch a team building on either model between now and mid-January, each one sourced in the paragraphs that follow.

Black Friday lands three days before the price change

US retail traffic from AI assistants is expected to be a real channel this season. Adobe expects AI traffic to US retail sites this holiday season to rise 130% year over year, with Black Friday up 95% - Adobe. Salesforce goes further, predicting that "20% of all 2026 holiday ecommerce traffic will originate from AI chat agents" - Salesforce. Treat both as forecasts, but the direction is clear, and the distribution surfaces are opening at the same time. OpenAI introduced Businesses in ChatGPT in beta, where companies can "claim their organisation," add "self-service product feeds with pricing and availability," and see mentions, clicks and "discovery topics," and where eligible US businesses can sponsor a Business Agent as the destination for ChatGPT ads - IT Brief. Our Business Hub setup guide covers the steps.

For the model decision, the holiday matters in two ways. First, do not migrate a customer-facing model in the week of November 23. The breaking changes in Section 11 fail loudly, but behavior changes (a model that thinks longer, stops earlier or writes differently) fail quietly, and peak traffic is the worst time to find them. Freeze your model configuration before Thanksgiving and change it afterwards. Second, a shopping or support agent answering holiday traffic should run on the cheap tier, with a frontier model reserved for the rare hard case. At $0.10 and $0.50 per million tokens, the cheap models make high-volume conversational traffic affordable in a way neither Fable nor Carbon can.

The building side is moving too. Cursor's Build Live Apps, launched November 5, lets its agent "spin up a Postgres database if needed," "set up authentication behind Cursor SSO" and "provision hosting," and says "Nothing goes live until the checks pass and you explicitly publish the app" - Cursor. On platforms like these, the platform picks the default model for you, and those defaults moved more than once this month (Claude Code made Fable 5.2 its default Fable model on launch day, and Google made Hydrogen the default for its managed Antigravity agent two days after Carbon's release). Knowing what each default costs per task is part of choosing the platform.

November 30 and December 1: prices and retirements

Carbon's introductory pricing ends on November 30, and Argon's with it. From December 1, plan on $4 and $20. The same weekend, Anthropic retires claude-sonnet-4-5-20250929 on November 30, with claude-sonnet-5-5 as the replacement - Anthropic. OpenAI's deprecations page lists November 30 for the /v1/prompts endpoint and reusable prompt objects and for Agent Builder (pointing users to the Agents SDK or ChatGPT Workspace Agents), while its Evals dashboard and API become read-only with a recommendation to "Migrate to Promptfoo" - OpenAI. On December 1, Google shuts down gemini-2.5-pro and gemini-2.5-flash, with requests automatically routed to gemini-3.8-flash and gemini-3.5-flash-lite respectively - Google. An automatic reroute keeps an app running but silently changes its model, which is the kind of change that should be tested, not discovered. Our Gemini 2.5 migration guide covers that move.

Later dates matter for anyone running a multi-vendor stack. OpenAI retires gpt-5 and o3 (and the related mini, nano and pro variants) on December 11, with gpt-6.1-sol as the listed replacement (OpenAI has since released a newer GPT-6.2 Sol - OpenAI), and GPT-4o, GPT-4.1 and their mini versions on January 14, 2027, all pointing to gpt-6-luna, per the same OpenAI page. Against that churn, the earliest retirement date Anthropic gives for Fable 5.2 is "Not sooner than November 9, 2027." Google has published no retirement date for Carbon.

Your keys are now worth stealing

The October security incidents changed the risk profile of holding frontier-model keys. Railway's preliminary report said the attacker was "attempting to obtain AI provider API keys to perform distillation attacks," and that at most 1.85% of workspaces, about 100,000, could have had environment variables decrypted - Railway. Its final report, published November 10, estimated unauthorized spend on stolen keys at about $740,000, said linked-account tokens for 1,852 users were decrypted, and listed the vendors asked to revoke keys, including Anthropic, OpenAI, OpenRouter and Google - Railway. Fireworks AI widened its own disclosure on November 9 to "account and billing information" and "a subset of incomplete model weights and datasets," and on November 17 reported "two separate security incidents," with account and billing information accessed "for all accounts created before Oct 30th" - Fireworks AI.

A first-principles reading: the more expensive the model behind a key, the more a stolen key is worth to an attacker, and the more it costs its owner before anyone notices. A leaked Fable 5.2 key bills $40 per million output tokens to whoever holds it. Two controls cap the blast radius. Google's spend limit per 10-minute window, which Section 12 described as a throughput constraint, is also a ceiling on what a stolen key can burn. On Anthropic's side, use separate workspaces per product and environment, with their own rate limits set through the Console or the Rate Limits API, so one leaked key cannot drain everything. Beyond that: keep keys out of build-time environment variables where possible, rotate them on a schedule, and give each agent its own credential. Our guide to giving an AI agent an identity instead of a shared API key goes deeper.

14. Build on Both: A Routing Architecture

The structural argument

Start from what is actually being bought. A product does not buy "a model"; it buys finished tasks of several different kinds, each with its own value, difficulty and tolerance for delay. The evidence in this guide shows the two models winning different kinds of task: Fable on long-horizon coding, computer use and interactive reasoning, Carbon on document-heavy analysis, long outputs, native multimodal input and some terminal work, and the cheap tier on everything routine. Ten days in November produced seven notable releases. A product that hard-codes one frontier model is betting that this month's ranking holds, and the last ten days say it will not.

So the decision that lasts is not "Fable or Carbon." It is the architecture that lets each task class go to the model that is best for it today, and lets you change that mapping with a configuration change and an evaluation run instead of a rewrite.

Where to route, and where not to

The constraint that shapes this architecture is reasoning state. Section 11 showed that on Anthropic's API a conversation can move up onto Fable 5.2 and keep its reasoning, but cannot move down off it without losing it. Reasoning does not cross between vendors at all. Two rules follow from that:

  1. Route at task boundaries. Decide the lane when a job or conversation starts, from what the request is, not turn by turn.
  2. Escalate within a family, upward only. Inside the Anthropic lane, start on Sonnet 5.5 or Opus 5.5 and escalate to Fable 5.2 mid-conversation when the work turns out harder than expected. The reasoning carries over. Do not bounce a running conversation between vendors.

The router itself should be cheap and calibrated. A small model from the cheap tier can classify requests, and Google's new Decisions API is built for exactly this: it returns calibrated probabilities over a set of choices "with zero output tokens," priced at $0.10 per million input tokens - Google. Calibrated probabilities let you route on a threshold ("send to the frontier lane only if the chance this is a hard multi-step coding task exceeds 0.7") instead of trusting a single label. Our guide to cutting agent costs with model routing covers router design in detail.

Read the diagram as a shape, not a prescription: which lanes you need and which model sits in each depends on your traffic. What generalizes is the structure. A cheap router decides at the start. Each vendor lane escalates upward inside its own family. Carbon's distinctive capabilities (native video and audio, near-million-token outputs) get a lane of their own where no other model can do the job. And every lane reports cost per finished task, not cost per token, along with the model that actually answered, so fallbacks show up in the data.

Making the lanes cheap to run

Each lane should keep a stable prompt prefix so caching works: explicit cache breakpoints on Anthropic's side, and on Google's side a prefix of at least 4,096 tokens that stays byte-identical so implicit caching can hit. Each lane needs its own evaluation set drawn from real production traffic (Section 12 explained why staged evaluations are becoming less predictive), and each frontier lane needs an effort sweep: Fable at medium, high and xhigh, Carbon at low, medium and high. Budget every Google lane at December prices. And re-run the sweep each time a lab ships, because in November that meant three times in ten days.

One concrete example of a fixed rule for choosing defaults comes from Founden, the company that publishes this site, which builds autonomous software for founders with Claude Code, Codex or Google's Antigravity as the AI coder. 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 19, 2026, that rule puts Antigravity builds on Gemini 4 Carbon and Claude Code builds on Claude Sonnet 5.5, not on Fable 5.2. At a 40% price weight, Fable's lead on the index does not cover its price for a general-purpose default. Fable becomes the right model only for the share of work where its lead decides the outcome, which is the routing argument of this section made into a rule.

15. Verdict and Decision Checklist

The question in this guide's title has a clearer answer than the price sheets suggest, as long as it is asked per workload.

Fable 5.2 is the stronger model, and at high effort it is not the expensive one. It leads every broad independent index, decisively on long-horizon coding, computer use and web development. At its API default it costs only 17% more per index task than Carbon at Carbon's standard price, and less per coding-agent task. Its reputation for expense comes from max effort, which costs three to six times as much as high and, on the coding-agent index, scores lower. Use it at high, escalate to xhigh only where you have measured a gain, and treat max as a measurement tool.

Carbon is a strong model at a temporary price, inside a lineup Google has already moved past. It is level with or ahead of Fable on legal, tax and document-heavy analysis, terminal work at a fraction of the cost, static abstract reasoning and general text preference. It reads video and audio natively and writes near-million-token outputs. Those are real reasons to route work to it. But it is slow, verbose in agent loops, gated behind Ultra in Google's apps and verification on Google Cloud, and Google's own safety report calls it an increment over Argon. From December 1, Neon matches its index score for less, and for most Google-lane work Neon is the better default.

For most products, the right answer is both, plus the cheap tier. Route routine traffic to a $0.10-per-million model, send long-horizon agentic work up the Anthropic family to Fable 5.2, and give Google's lane the multimodal and long-output work it is uniquely good at.

A short checklist to turn that into a decision this week:

  1. List your task classes (for example routine chat, document analysis, long coding jobs, media understanding) and the volume and value of each. The decision is per class.
  2. Pull a few hundred real tasks per class and run them on both models at two or three settings each. Record tokens, minutes, success rate and the model that actually answered.
  3. Compute cost per finished task at December prices for Carbon, including retries. Compare that, not the per-token rate.
  4. Use November's discount for fixed-size jobs: backfills, evaluation runs and bulk analysis on Carbon at Batch or Flex rates before November 30.
  5. Fix the migrations before you switch: append-only history and the new computer use toolset for Fable; removed explicit caching, a larger output budget and longer timeouts for Carbon.
  6. Set capacity and safety controls: Anthropic tier and workspace limits, Google's spend tier, separate keys per environment and agent, and a context-budget message for long Fable runs.
  7. Freeze customer-facing model changes from November 23 to after Black Friday, then revisit the mapping monthly. Neon and GPT-6.2 Astra arrived in the same ten days as these two models, and the next release will come sooner than your next quarterly review.

For a broader view of how the main model families compare for building a product, our guide to choosing the best AI model to build your app covers the selection process, and our earlier comparison of GPT-6 Astra and Fable 5.1 shows how the same trade-offs looked one release ago. The models change every few weeks. Measuring cost per finished task, routing at task boundaries and keeping the model a configuration value hold up across releases.

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 Haiku 5.5 (Anthropic): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1M token window, listed 7 October 2026.
  • GPT-6 Luna (OpenAI): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1.05M token window, listed 22 September 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.

In this topic: AI models

Which AI model should you build on? Every guide on it

Data behind this topic: AI model prices, context windows and release dates.