Claude Fable 5.2 vs Opus 5.5: Real Cost per Task (2026)

Fable 5.2 costs twice as much per token as Opus 5.5. On some agent work it is still the cheaper model per finished task, and on other work it costs three times as much for nothing. This guide shows which is which, with the arithmetic.

On November 9, 2026, Anthropic released Claude Fable 5.2 at $8 per million input tokens and $40 per million output tokens, a 20% cut from the $10/$50 that Fable 5.1 charged - Anthropic. Claude Opus 5.5, the model most teams already run their agents on, stays at $4 in and $20 out, exactly half - Claude pricing. On Scale Labs' Remote Labor Index, a test built from real freelance projects, Fable 5.2 automates 41.3% of the work against 21.25% for Opus 5.5, close to double the success rate at double the token price - Scale Labs.

So the obvious question has an obvious-looking answer: if the expensive model succeeds twice as often, the cost per finished task comes out even. It does not, and the reasons are more useful than the answer. Anthropic's own developer documentation still tells most teams to start with Opus 5.5 and move to Fable 5.2 only when evaluations on Opus at higher effort still fall short - Claude Docs. Its own cost guide reports Fable 5.2 costing 2.9 times as much as Opus 5.5 on a deep-research benchmark for a score 1.9 points lower - Claude Docs. And its launch charts show Fable 5.2 matching Opus 5.5's best agentic-coding score for roughly half the cost per task - Anthropic on X. All three are true at once.

The practical problem: a per-token price is the wrong unit for an agent. An agent is billed for a whole trajectory: dozens of requests, most of their input read back from a cache, thinking tokens you never see, retries, and the occasional run that never finishes. The model that looks cheaper per token can be the expensive one per completed job, and the reverse.

This guide works out the real cost per agent task for the two models from first principles. It covers the price sheets line by line (including the one price the two models share), the formula an agent bill actually follows, how the effort setting moves cost more than the choice of model, every per-effort data point Anthropic published for both models, the counter-evidence in Anthropic's own documentation, independent measurements, the break-even cost of a failure that decides when the premium pays, the tasks Opus 5.5 never finishes at any price, speed, failure modes that still bill, subscriptions, routing between the two, and a method to measure all of it on your own work. Every number links to its source, and every derived number shows its arithmetic.

This guide reflects prices and measurements as of November 11, 2026, two days after Fable 5.2's release. Model prices in the text update from the model catalog automatically; benchmark figures do not, so check the linked sources before committing a budget.

Contents

1. The Price Sheets Side by Side
2. Cost per Agent Task From First Principles
3. Effort Is the Real Price List
4. What Anthropic's Launch Charts Actually Show
5. The Counter-Evidence in Anthropic's Own Cost Guide
6. Independent Measurements
7. The Remote Labor Index and the Price of a Finished Job
8. Break-Even: When the Expensive Model Is Cheaper
9. Capability Ceilings: Work Opus 5.5 Never Finishes
10. Speed, Fast Mode and the Cost of Waiting
11. Failures That Still Send a Bill
12. Subscriptions, Claude Code and Seats
13. Routing Between the Two Models
14. How to Measure Cost per Task on Your Own Work
15. The Market Around the Decision This Week
16. Verdicts by Workload and the Bottom Line

Scorecard: Which Model Is Cheaper per Finished Task, by Workload

Before the detail, the answer in one table. Each row compares the cheapest setting of each model that reaches the same result, because that is the comparison a buyer actually faces. "Same effort label" comparisons, which most reviews use, are misleading for reasons section 3 explains. All figures are Anthropic's measurements unless marked otherwise, since independent per-task measurements of Fable 5.2 are still only two days old (section 6 adds what exists, and the Remote Labor Index row is Scale Labs' leaderboard).

The pattern behind the table is simple to state and is the thesis of this guide: Fable 5.2 is cheaper per finished task only where Opus 5.5 has to climb to its top effort settings to reach the result, or cannot reach it at all. On work that Opus 5.5 already solves at its default setting, the extra capability buys little and the token price doubles. Sources for every row are in sections 4 to 7.

1. The Price Sheets Side by Side

Start with what each token costs, because the structure of the price sheet decides how much of the 2x headline premium survives into a real bill. Anthropic publishes six prices per model, plus two speed and latency tiers that change them.

The write, batch and data-residency rows come from Anthropic's pricing page, which also confirms that both models include their full 1M-token context window at standard rates, with no surcharge for long prompts - Claude pricing. Fable 5.2 caps output at 128K tokens per response - Claude release notes, the same ceiling as Opus 5.5's 128K tokens.

1.1 The one price the two models share

The row that matters most is the one that does not double. A cache hit costs $0.20 per million tokens on both models. Anthropic gets there by pricing cache reads at 0.025x the base input price on Fable 5.2 and 0.05x on Opus 5.5, while almost every other Claude model uses the standard 0.1x - Claude pricing. Opus 5.5 earned its multiplier at launch, when its cache reads fell 60% below Opus 5's $0.50 - Anthropic.

Why this matters so much for agents: an agent resends its whole conversation on every turn, so the cached prefix is usually the largest single block of tokens in the bill. Across 14 days of first-party API traffic, Anthropic measured agent loops reading a median 84.2% of all their input tokens from the cache, with the upper quartile at 91.7% - Claude Docs. Every one of those tokens costs the same on Fable 5.2 as on Opus 5.5. The 2x premium only applies to the rest: new input, cache writes and output.

1.2 Same tokenizer, so a token is the same unit

Comparisons between labs have to correct for tokenizers, because the same text can become a different number of tokens. This comparison does not. Fable 5.2 uses the tokenizer introduced with Claude Opus 4.7 - Claude Docs, and Anthropic's pricing page states that Claude 4.7 and later models all share it - Claude pricing. A million tokens of your codebase is a million tokens on both models, so any difference in token counts between them comes from behavior (how much each model reads, thinks and writes), never from how text is cut up.

1.3 Two symmetries that create real options

Two features of the price sheet line up in a way that is easy to miss. First, Fable 5.2 through the Batch API costs exactly what Opus 5.5 costs in real time: $4 in and $20 out. Batch processing gives a 50% discount on both input and output for work that can wait up to 24 hours - Claude pricing. Any job that does not need an answer in the next few minutes (overnight evaluation runs, document review queues, a backlog of research briefs) can get the stronger model at the weaker model's real-time price.

Second, Opus 5.5 in fast mode costs exactly what Fable 5.2 costs at standard speed: $8 in and $40 out. Fast mode runs the same model on a faster inference configuration, up to 2.5x more output tokens per second, with no change in intelligence - Claude Docs. So for the same spend per token you can buy either more speed or more capability, which turns the model choice into a question about whether your bottleneck is a person waiting or a task failing. Section 10 works through it.

1.4 What the price sheet leaves out

The price sheet also hides three behaviors that move the bill more than any line on it. Default effort differs: the API runs Fable 5.2 at high unless told otherwise and Opus 5.5 at medium - Claude Docs, so two requests that omit the setting are not doing the same amount of thinking. Thinking cannot be turned off on either model, and thinking tokens bill as output. And Fable 5.2 runs one breaking change that can raise output tokens if a harness edits its own history: the API now checks on every account that replayed thinking blocks belong to an unedited conversation - Claude release notes. The next two sections turn these into numbers.

2. Cost per Agent Task From First Principles

The structural question is not "which model is cheaper" but "what does a finished unit of work cost, and what is it made of". An agent does not buy tokens. It buys outcomes: a pull request that passes tests, a research brief a person can act on, a spreadsheet that reconciles. Tokens are an input, and the bill is the sum of every request the agent makes on the way to the outcome, plus whatever it costs when the outcome does not arrive.

2.1 The formula an agent bill follows

Anthropic bills each request in five buckets, and a task is the sum of its requests. Anthropic's own instructions for pricing a task list exactly these: uncached input, 5-minute cache writes at 1.25x the input price, 1-hour cache writes at 2x, cache reads, and output - Claude Docs. In an agent loop that caches correctly, each request reads everything it sent before from the cache and writes only what is new (the latest tool result and the model's previous reply). So, per task:

Cost per attempt = (cache reads x $0.20) + (new tokens written x write price) + (uncached input x input price) + (output and thinking x output price)

Cost per finished task = cost per attempt / success rate, plus the cost of handling the tasks that never finish

The first line explains why the headline premium shrinks. The cache-read term is identical on both models, and it grows with the square of the number of turns, because every turn re-reads every earlier turn. The second line explains why the premium can disappear or reverse: if the expensive model finishes more tasks, or finishes them in fewer turns, it divides by a larger number.

2.2 A worked example: one 40-turn agent loop

To make the formula concrete, here is one illustrative coding agent loop priced both ways. The assumptions are not a measurement, they are a typical shape: a 15,000-token system prompt and tool set, 40 turns, each turn adding a 2,500-token tool result and a 1,200-token reply (thinking included), priced the way Anthropic meters a customer: prior prompt as a cache read, new tokens as a 5-minute cache write, output at the output price. The trajectory is held identical on both models, so the only variable is the price sheet.

On an identical trajectory, Fable 5.2 costs 1.73x what Opus 5.5 costs, not 2x, because 95% of the input in this loop is a cache read priced the same on both. Switch caching off and the ratio goes back to exactly 2x, while both bills grow about sixfold. Anthropic's own measurements agree on the size of that second effect: on its SWE-bench Pro runs, Opus 5.5 without caching cost 3.3 times what it cost with caching - Claude Docs.

The third line in the chart shows the case that matters in practice. If Fable 5.2 thinks 50% more per turn but finishes in 30 turns instead of 40, it costs $3.99, still 1.65x Opus 5.5. Fewer turns help a little, because they shrink the quadratic cache-read term, but they do not close the gap on their own. What closes it is the success rate, which is why the rest of this guide is about how often each model finishes, and at what effort.

2.3 Why "cost per solved task" can mislead

The most common shortcut divides cost per attempt by the pass rate and calls the result "cost per solved task". On Anthropic's FrontierCode 2.0 data that shortcut favors Opus 5.5 at every single effort level: at medium effort, $1.70 / 30.1% = $5.65 for Opus 5.5 against $2.48 / 37.6% = $6.60 for Fable 5.2 (figures from the chart data in section 4). Read naively, Opus 5.5 always wins.

The shortcut assumes that a failed task can simply be retried until it succeeds, with each retry an independent coin flip. That is true for tasks near a model's ability and false for tasks above it. A task Opus 5.5 cannot solve at medium effort is usually one it also fails on the second and third attempt, because the failure comes from the task's difficulty rather than from bad luck. Anthropic's cost guide makes the same point in plainer words: "The bill is decided by the tasks the cheaper model fails, because a failed task still bills its tokens, then the retry, then whatever the failure costs downstream" - Claude Docs. Two better measures replace the shortcut in this guide: the cost to reach a given quality bar (section 4) and the break-even cost of a failure (section 8).

3. Effort Is the Real Price List

Both models think before they answer, both always think (neither accepts a request to switch thinking off), and both expose five effort levels: low, medium, high, xhigh and max. Effort governs how much thinking, tool calling and self-checking a model does, and it applies to every output token, including tool calls - Claude Docs. Because thinking bills as output, effort is the largest single dial on an agent's cost, larger than the choice between these two models.

3.1 The defaults are not the same

The detail that breaks most casual comparisons: on the API, Fable 5.2 defaults to high and Opus 5.5 defaults to medium. Anthropic's effort documentation states that high is the default on every model that supports effort "except Claude Opus 5.5 and Claude Haiku 5.5", where it is medium - Claude Docs. Inside Anthropic's own apps the picture differs again: Medium is the default effort for Fable 5.2 in the Claude apps and Claude Code - Anthropic.

So a developer who swaps the model string in an API call, and changes nothing else, also moves their agent from medium to high effort. On FrontierCode 2.0 that combined change takes the cost per task from $1.70 to $6.72, a factor of 3.95, of which only part is the price sheet. Anyone reporting "Fable 5.2 costs four times as much" after a model swap is mostly reporting the effort change.

3.2 What each effort level costs on each model

Anthropic's launch pages chart five benchmarks at every effort level for both models, with cost per task. Reading the chart data directly (each point carries its exact score and cost), the ratio of Fable 5.2's cost to Opus 5.5's cost at the same effort label is:

Ratios are computed from the per-effort points in the charts on Anthropic's Fable 5.2 launch page - Anthropic. Two readings follow. At the same label, Fable 5.2 usually costs 1.2x to 2.8x as much as Opus 5.5. Since the price sheet alone accounts for at most 2x (less in a cached loop), a ratio below 2x means Fable 5.2 is spending fewer tokens than Opus 5.5 at that label, which is the case at medium on every benchmark here and at most WANDR settings, while a ratio near 2.8x (FrontierCode at high and xhigh) means it is spending roughly 40% more. And the extreme ratios at low are not Fable 5.2 being wasteful: they are Opus 5.5 at low doing very little. On BenchCAD, Opus 5.5 at low spends $0.03 per task and scores 6.3, while Fable 5.2 at low spends $1.89 and scores 26.9. The two models interpret "low" differently, so the same label is not the same amount of work.

The real lesson is that labels are not a unit. Anthropic's documentation says so directly for Fable 5.2: effort levels run in the same order across Claude models, "but the amount of thinking behind each level can differ from model to model", so a setting tuned on Opus 5.5 should be re-swept rather than carried over - Claude Docs. The comparison that makes sense is along each model's whole curve, which is the next section.

3.3 Where the effort curve bends

The two curves have different shapes. Opus 5.5 climbs steeply from low to high and then flattens, so its expensive settings buy little: on Anthropic's SWE-bench Pro subset, xhigh scored about 1.4 points more than high for 2.5 times the cost - Claude Docs. Fable 5.2 starts higher and keeps climbing longer, but its top setting misbehaves: on FrontierCode 2.0, max scored 45.6%, below xhigh's 49.1%, at three times the cost ($44.70 against $14.19). Anthropic's guidance for Fable 5.2 is to start at high because "most of the gain in capability is already present at high", step to xhigh only where a gain has been measured, and reserve max for measuring the model's ceiling, since it "runs slower and costs more than at xhigh, often for only a small gain" - Claude Docs.

Anthropic's chart of the FrontierCode data, posted with the launch, shows both curves on one cost axis. The point to look at is where the green Fable 5.2 line sits above the orange Opus 5.5 line at the same horizontal position: that gap is the extra score Fable 5.2 buys for the same money.

From about $2 per task upward, the Fable 5.2 line runs above or level with the Opus 5.5 line (the two touch only around $5, where Opus 5.5 at xhigh sits on Fable 5.2's curve), and only Fable 5.2 reaches the high 40s. Below $2, only Opus 5.5 exists: its low and medium points at $0.75 and $1.70 have no Fable 5.2 equivalent. That shape, a cheap floor Opus 5.5 owns and a high ceiling Fable 5.2 owns, recurs on almost every benchmark Anthropic published - Anthropic on X.

4. What Anthropic's Launch Charts Actually Show

Anthropic's Fable 5.2 announcement includes accuracy-against-cost charts for five benchmarks, and each chart point in the page carries its exact score and cost per task. That makes it possible to answer the question buyers actually have, which is not "how much better is Fable 5.2 at max" but "what does each model cost to reach the same result?" The headline benchmark table on the same page reports every model at its highest effort, a setting few teams run in production - Anthropic.

These are vendor numbers on vendor-chosen benchmarks, so they carry the usual caveat: a lab picks the evaluations its new model wins. They are still useful here for a specific reason. Both models come from the same lab, run through the same harnesses and are priced at the same list rates, so the relative cost of the two models on a given task is far more trustworthy than any cross-lab comparison. Section 5 then adds the evaluations where Anthropic's own documentation reports the opposite result.

4.1 The cost to match Opus 5.5's best score

For each benchmark, the table finds Opus 5.5's best result (always at max effort), then the cheapest Fable 5.2 setting that reaches it.

All points come from the accuracy-against-cost charts on Anthropic's launch page - Anthropic. Anthropic's own summary of these comparisons matches the arithmetic: Fable 5.2 at High effort is "about level with Opus 5.5 at Max effort, for roughly half the cost per task" on FrontierCode 2.0 - Anthropic on X.

On four of five benchmarks, Fable 5.2 reaches Opus 5.5's ceiling for between 6% and 52% of the cost. BenchCAD is the exception worth understanding: there Fable 5.2 has no setting that lands exactly on Opus 5.5's 65.3. Its high scores 61.0 for $9.99 and its xhigh jumps to 74.1 for $23.23, so matching Opus 5.5 means overshooting it by nine points at slightly higher cost. If 65 is your bar, Opus 5.5 is the cheaper way to get there; if 74 is, only Fable 5.2 gets there at all.

4.2 Where Opus 5.5 still wins: the cheap end of every curve

The same data read from the other direction gives the opposite answer. Take the cheapest thing Fable 5.2 can do (its low setting) and ask what Opus 5.5 charges to match it:

Even at its cheapest, Fable 5.2 matches or beats Opus 5.5's cost for the same result on these five charts. Where Opus 5.5 wins is below Fable 5.2's floor: work whose quality bar is low enough that Opus 5.5 at low or medium clears it. On FrontierCode, Opus 5.5 at medium scores 30.1% for $1.70, a result Fable 5.2 has no setting for, since its cheapest point already costs $2.10. On WANDR, Opus 5.5 at low scores 31.2% for $1.25, a tenth of Fable 5.2's cheapest run. If that level of result is enough for the job, Opus 5.5 is the only sensible choice.

The WANDR chart shows this structure more starkly than any other. Opus 5.5's line starts at a dollar and change and climbs steeply. Fable 5.2's line starts at $12.66, already above where Opus 5.5 ends at its xhigh setting, and never comes down.

The chart makes the trade concrete. There is a band of cheap, moderate-quality search work (roughly $1 to $11 per attempt, scores of 31% to 63%) where only Opus 5.5 operates, and a band of high-quality search work (above 72%) where only Fable 5.2 operates. Between them, Fable 5.2 at low beats Opus 5.5 at high on both score and cost.

4.3 Three caveats about the launch numbers

First, effort labels again. Anthropic's headline table reports Fable 5.2's FrontierCode 2.0 score at xhigh (49.1%) and the others at their maximum - Anthropic, which is legitimate (Fable 5.2's max scored lower) but means the headline gap of 3.6 points over Opus 5.5 costs $14.19 per task against $12.82, not the "half the cost" that the matched comparison gives.

Second, costs move between pages. Anthropic charted WANDR on both the Opus 5.5 and the Fable 5.2 launch pages with identical Opus 5.5 scores but slightly different costs: $11.20 and $37.92 at medium and max in September - Anthropic, against $11.40 and $38.68 in November. The 2% drift is small, but it is a reminder that "cost per task" in a chart is a computation over recorded token counts at a price list, not an invoice, and that two runs of the same agent cost different amounts.

Third, these are single-attempt averages over a benchmark. The cost per task is a mean, and agent costs have long tails. On a 20-problem WideSearch run, Anthropic found two problems carrying 43% of the total spend - Claude Docs. A model that is cheaper on average can still be the one that produces your most expensive single run, which matters for budgets and spend caps (section 11).

5. The Counter-Evidence in Anthropic's Own Cost Guide

If the launch charts were the whole story, the conclusion would be "switch everything to Fable 5.2". Anthropic's developer documentation says the opposite: "For most workloads, start with the latest Claude Opus model" and move to Fable 5.2 "when your evals on a Claude Opus model at higher effort still don't meet your requirements" - Claude Docs. Even the official launch video's description repeats it: "For most coding and knowledge tasks, we recommend starting with Opus 5.5" - Claude on YouTube. The reason is in a document most buyers never read: Anthropic's guide to optimizing for cost and intelligence, which publishes measured cost per task across its own internal benchmark runs.

The clip itself is a short launch teaser; what matters for cost is the line under it, which positions Fable 5.2 for "the most ambitious, open-ended technical work" and Opus 5.5 for everything else.

5.1 Routine coding: Opus 5.5 at a fraction of the cost

On a subset of SWE-bench Pro (real repository issues checked by tests, 463 problems that run without network access), the measured results are:

The figures come from Anthropic's cost guide, priced "as a customer is billed" from the runs' own usage records - Claude Docs. At a similar pass rate, Opus 5.5 at xhigh matches Fable 5.2 at high "for a little over half the cost", and Opus 5.5 at its default solves 93.1% for under a quarter of a dollar. The guide also notes that both Opus 5.5 and Fable 5.1 "largely saturate" this subset. Note too that it is not the public SWE-bench Pro leaderboard: Anthropic says these scores are not comparable to it.

Saturation is the whole explanation. When the cheaper model already solves 93% of the tasks, the stronger model can add at most seven points, and it charges for its tokens on all hundred. The arithmetic of section 2 then has nothing to work with: the success rate in the denominator barely moves, while the cost in the numerator doubles or more. Most production coding work (well-specified tickets in a familiar codebase) looks more like this benchmark than like FrontierCode.

5.2 Deep research: more money, no better report

On DeepResearch Bench II, a benchmark of 132 research tasks graded against expert-written rubrics, Anthropic ran Fable 5.2 before release on 46 tasks of a 50-task subset. The result is blunt: "Claude Fable 5.2 cost 4.3 times as much as Claude Sonnet 5.5 for no measurable gain in score, and 2.9 times as much as Claude Opus 5.5 for a score 1.9 points lower" - Claude Docs. Its own effort sweep was nearly flat: 54.5% at low for $1.49, 55.0% at medium for $2.16, and 57.7% at high for $4.82 per task.

The methodology notes carry one oddity worth knowing. The test harness cut any search query longer than 120 characters, and this happened on 57% to 59% of Fable 5.2's searches against 26% to 31% for most other settings, although Anthropic reports that Fable 5.2's runs with more cut searches did not score lower within a task - Claude Docs. Fable 5.2 writes longer, more specific search queries, which is a behavior to watch in any harness with query limits.

The deeper reason this result differs from WANDR is what each benchmark rewards. WANDR scores whether an agent finds hard-to-find facts, a task with a right answer that more capability helps reach. A rubric-graded research report rewards coverage and structure, which every frontier model already produces well, so extra reasoning shows up as cost rather than score. The same split appears in Anthropic's Fable 5 data: across WideSearch, DeepWideSearch, BrowseComp and GDPval, medium effort matched the default's accuracy at 70% to 87% of its cost, and the default "bought nothing measurable over medium on any of the four" - Claude Docs.

5.3 A mixed internal coding suite: the curves cross

The richest data point sits between the two. On an internal suite of 370 repository tasks graded by the repositories' own tests, Anthropic swept both models across effort levels with a plain API agent, priced as a customer is metered:

Every row comes from the benchmark notes in Anthropic's cost guide - Claude Docs. Fable 5.2's rows are single runs, while the Opus 5.5 medium and high rows average five attempts per task, so treat a point or two either way as noise.

Read along the curves, the suite shows the crossing that sections 4 and 5 predicted. Up to about 87%, Opus 5.5 at its default is the cheapest way to get there, at $0.84 per attempt. Around 88% to 89%, Fable 5.2 at low is cheaper than Opus 5.5 at high for the same pass rate ($1.05 against $1.38). Above 91%, only Fable 5.2 at high gets there, and it costs $5.39 against $4.11 for Opus 5.5 at xhigh, which tops out 2.4 points lower. The two-model pairing that Anthropic tested in September (Opus 5.5 executing, Fable 5.1 advising) reached 90.1% for $2.92, which Fable 5.2 alone at low now nearly matches for about a third of the cost.

Whether those extra points are worth the money depends entirely on what a failed task costs you, which is exactly the break-even question section 8 answers. For a team whose failed agent run means a developer spends twenty minutes cleaning up, a few points of pass rate are worth many dollars per attempt. For a team that runs thousands of attempts and discards the failures, they are not.

5.4 Reconciling the launch page with the cost guide

The two documents are not in conflict. They measure different kinds of work:

• Unsaturated, long-horizon, hard-to-verify tasks (FrontierCode 2.0, WANDR, the Remote Labor Index, BenchCAD at high scores): Opus 5.5 tops out below what the task needs, so it climbs to max and still falls short. Fable 5.2 reaches the same result at a lower setting, and its higher token price is more than offset.
• Saturated or rubric-graded tasks (the SWE-bench Pro subset, DeepResearch Bench II): Opus 5.5 already performs near the ceiling at its default, so Fable 5.2's extra capability has nowhere to go and its price premium flows straight into the bill.

This is the first-principles core of the comparison. The premium model pays for itself only on the share of your workload that sits above the cheaper model's ceiling. So the useful question for any team is not which model is better, but how much of its work lives above Opus 5.5's ceiling at a reasonable effort setting. That share is usually small, and it is usually where most of the value is.

6. Independent Measurements

Two days after launch, three independent evaluators had already published per-task costs for both models, and a fourth (the Remote Labor Index) had scored Fable 5.2. None of them was designed to answer this guide's question, and they run different harnesses at different effort levels, so their absolute numbers do not compare with each other. What they share is more useful than any single number: the same shape that Anthropic's own charts show.

6.1 Artificial Analysis: the same crossing, measured independently

Artificial Analysis runs both models at every effort level through its Intelligence Index, a suite of nine evaluations spanning knowledge work, coding, science and reasoning, and publishes the cost per task for each configuration - Artificial Analysis. Sorted by cost, the ten configurations line up like this:

The pattern is the one from section 4, now from an evaluator with no stake in the result. Below about $3 per task, only Opus 5.5 exists, and its medium setting is the cheapest way to score in the high 40s. From about $3 upward, Fable 5.2 scores higher at almost every price point: Fable 5.2 at low beats Opus 5.5 at high for less money, and Fable 5.2 at high beats Opus 5.5 at max for less money. The one exception is a narrow band between about $6 and $9 per task, where Opus 5.5 at xhigh (57) edges Fable 5.2 at medium (56). Fable 5.2 at max tops the table at 65, and it is also by far the most expensive configuration, at $26.54 per task and 274k tokens per task - Artificial Analysis.

The index's component scores show where the extra capability lives, which matters more than the average. Fable 5.2's lead is large on technical and knowledge-heavy evaluations: at max effort it scores 80.2% on HLE-Diamond against 67.9%, 76.5% on the hard subset of CritPt against 68.0%, 73.3% on Terminal-Bench-Science against 59.0%, and 67 against 48 on AA-Omniscience. On business documents the picture flips: Opus 5.5 scores 26.2% on GDP.pdf at max against Fable 5.2's 24.2% (and 28.8% at high), and edges it on the AA-Briefcase knowledge-work Elo, 1801 against 1785. On Terminal-Bench 4.0 the two tie at 59.6% at max effort. All of these come from the same comparison table - Artificial Analysis.

That split is the independent version of section 5's finding. When the work is technical, unsaturated and has a right answer, Fable 5.2's capability converts into score. When the work is a well-formed business deliverable, both models are near what the grader can distinguish, and Fable 5.2's extra thinking converts into cost.

6.2 Vals AI: Fable 5.2 at high against Opus 5.5 at max

Vals AI runs a suite of professional tasks (finance, tax, legal research, code migration, terminal work, building apps) and reports cost per test. Its Fable 5.2 entry was evaluated at High effort - Vals AI, while its Opus 5.5 entry ran at max - Vals AI. As of November 9, the index shows:

Those rows come from the Vals Index table - Vals AI. The comparison is lopsided in effort, but in the useful direction: it pits Fable 5.2 at its default against Opus 5.5 pushed to its ceiling, which is the trade a team faces when Opus 5.5 is not good enough at lower settings. Fable 5.2 comes out about a point higher for 72% of the cost, half the tokens and half the time. That is the same "Fable 5.2 at high is about Opus 5.5 at max for less" relationship Anthropic reported on FrontierCode 2.0, reproduced on a different suite by a different harness.

6.3 CursorBench: interactive coding favors Opus 5.5

Cursor publishes CursorBench, which evaluates agents "on ambiguous, multi-file tasks from real Cursor sessions", with cost, tokens and steps per task for every effort level - Cursor. It is not neutral (it measures one product's harness), but it is the closest public proxy for the coding work developers hand an agent inside their editor, and it tells the opposite story from FrontierCode:

Here Opus 5.5 at high is the sweet spot: for the same $3.94 to $3.97 per task, it scores 56.0% where Fable 5.2 at low scores 53.2%, and Fable 5.2 needs $9.70 at high to add less than a point. Only at the very top does Fable 5.2 pull ahead, at 60.0% for $32.79, more than double Opus 5.5's max cost. The same page lists Gemini 4 Carbon at high scoring 60.4% for $9.22 per task, ahead of both - Cursor.

Why would editor-based coding behave differently from FrontierCode? The likeliest reason is task length and scope: tasks drawn from real editor sessions are, by construction, the size of work a developer delegates in one sitting, much of which sits within Opus 5.5's ability at moderate effort, while FrontierCode tasks are long, open-ended engineering problems where the agent works alone for a long time. The same model pair, measured on two kinds of coding, gives opposite verdicts, which is the strongest argument in this guide for measuring on your own work rather than adopting anyone's headline.

6.4 What the independent numbers agree on

Put side by side, the independent evaluators agree on three things. Opus 5.5 is the only option for the cheapest tier of work, roughly under $3 per task on these suites. Fable 5.2 at its default (high) roughly matches Opus 5.5 at its ceiling (max), for somewhere between 72% (Vals) and 90% (Artificial Analysis) of Opus 5.5's maximum cost. And in between, the winner depends on the type of work: technical and research-heavy suites favor Fable 5.2 at its lower settings, while interactive coding and business documents favor Opus 5.5 at medium to high. For a monthly view of how these two sit among twenty models, our November LLM ranking for AI agents applies the same cost-per-finished-task lens across vendors.

7. The Remote Labor Index and the Price of a Finished Job

The single most striking number in Fable 5.2's launch is its Remote Labor Index score, and it is also the best test of the "per finished task" idea, because RLI measures finished work in dollars.

7.1 What RLI measures

RLI is built from 240 real freelance projects collected from 358 verified freelancers across 23 Upwork categories, each with the client's brief, the input files, the professional's accepted deliverable, and the time and price the professional reported - Scale Labs. The deliverables span documents, audio, video, 3D models and CAD files. The headline metric, the automation rate, is the share of projects where an AI's deliverable is judged at least as good as the human standard, meaning a "reasonable client" would accept it. When the leaderboard launched, the best agent automated 2.5% of projects.

The paper behind it puts a price on the work: the projects average $632.60 each, with a median of $200, and took professionals a mean of 28.9 hours (median 11.5) to complete - arXiv. Agents get at most $30 of generation budget per task, a cap Scale applies to standardize cost across models - Scale Labs.

7.2 The scores

On the current leaderboard, Fable 5.2 automates 41.30% of projects, Opus 5.5 21.25% and Fable 5.1 17.92% - Scale Labs. Anthropic's launch table reports the same 41.3% for Fable 5.2 at high effort, with GPT-6 Astra at 20.8% - Anthropic. In about a year, the best automation rate on the index has gone from 2.5% to above 40%, and the step from Opus 5.5 to Fable 5.2 alone is twenty points.

7.3 The economics of a finished project

The leaderboard does not publish per-model costs for these runs, but the budget cap bounds them: neither model can have spent more than $30 on a project. That is enough to settle the question for this kind of work. Taking the paper's average project value, an attempt by Fable 5.2 completes $261 of client-acceptable work in expectation (41.3% of $632.60), against $134 for Opus 5.5 (21.25%). The difference, about $127 per attempted project, is more than four times the largest possible difference in token spend. Even at the median project value of $200, the difference is $40 of expected completed work against at most $30 of extra tokens.

Two cautions keep this from being an advertisement. First, "automated" means a judge accepted the deliverable as client-ready, which is not the same as a client paying for it, and every accepted deliverable in a real business still needs someone to review it before it ships. Second, the failures still cost something: in RLI's own cost-savings metric, a failed project counts as infinitely expensive, because a human has to do the whole job anyway - Scale Labs. Even so, for open-ended, multi-file, client-facing work, the direction is unambiguous: the model that finishes twice as many jobs wins by far more than its token premium, because the token bill is a rounding error next to the value of the job.

8. Break-Even: When the Expensive Model Is Cheaper

Sections 4 to 7 point to a general rule, and it can be written as one line of algebra. Let c be the cost per attempt, p the success rate and H what a failure costs you: the developer time to clean up, the human who redoes the job, the customer who churns, or simply the cost of the retry. Then the expected cost of running a task is c + (1 - p) x H, and Fable 5.2 is cheaper than Opus 5.5 whenever:

H > (c_Fable - c_Opus) / (p_Fable - p_Opus)

The right-hand side is the break-even failure cost: the premium per attempt divided by the extra success rate it buys. If a failed task costs you more than that, the expensive model is the cheaper one. If a failure costs less, or if the cheaper model has a configuration that matches the expensive one's success rate, the cheaper model wins.

8.1 Break-even values from the measured data

Applying the formula to the comparisons in sections 4 to 6 (each pair is a setting a team would realistically choose between):

Inputs are the per-attempt costs and pass rates from Anthropic's charts and cost guide and from Cursor's evaluation page, as cited in sections 4 to 6; the arithmetic is ours.

8.2 Reading the break-even against real failure costs

The numbers become decisions once you set them against what a failure actually costs. The median US software developer earns $64.44 an hour - BLS, before benefits and overhead, so thirty minutes of a developer cleaning up after a failed agent run costs about $32 in wages alone. Against that yardstick, every break-even in the chart up to FrontierCode's default-versus-default comparison is cleared by a single half-hour of human cleanup, and the $53 and $81 comparisons are cleared by an hour of it.

That is why the answer differs so sharply by workload:

• Where failures are cheap and automatic (a test suite catches them and the agent simply retries), H is just the cost of one more attempt, a few dollars or less. Opus 5.5 wins almost everywhere, and the right move is Opus 5.5 with a retry or escalation policy (section 13).
• Where failures need a person (a broken pull request someone has to untangle, a research brief someone has to redo, a customer-facing deliverable), H is tens to hundreds of dollars. Fable 5.2 wins wherever it raises the success rate by more than a few points.
• Where the cheaper model can match the success rate at a higher effort setting, the formula never favors the expensive model. The SWE-bench Pro row shows this: Opus 5.5 at xhigh already solves as many tasks as Fable 5.2 at high, for less, so no failure cost justifies the switch. CursorBench shows the near version of it: Fable 5.2 at high buys less than one point over Opus 5.5 at high, so a failure would have to cost over $600 to justify it.

The general rule follows: first move along Opus 5.5's own effort curve; consider Fable 5.2 only where that curve flattens below the success rate you need, and only if a failure costs more than the break-even. That is the same advice Anthropic's documentation gives in words, made checkable with numbers.

9. Capability Ceilings: Work Opus 5.5 Never Finishes

The break-even formula assumes both models can do the task some of the time. The most important cost difference between these two models sits where that assumption breaks.

9.1 When the cheaper model's cost per finished task is infinite

Anthropic's launch includes an unusual demonstration: a team of 1,000 Fable 5.2 agents formalized the proof of Fermat's Last Theorem in the Lean proof assistant in 30 hours, from minimal prompts, with no mathematical references and minimal human intervention. With the same 1,000-agent setup, Opus 5.5 completed 26% of the formalization in 18 hours and made little further progress by 30 - Anthropic. Anthropic also notes that Fable 5.2 used one third as many action tokens as its earlier formalization with an unreleased research model, which had taken 11 days with a purpose-built harness.

The chart is the cleanest picture of a capability ceiling. Both teams start at the same pace for the first hour. Then Fable 5.2 climbs in steps to 0.86 by hour 14 and to 1.00 after being resumed with 12 more hours, while Opus 5.5 flattens around 0.26 and ends at 0.27 - Anthropic on X. For this task, Opus 5.5's cost per finished task is not twice or ten times Fable 5.2's. It is undefined: no amount of spending finishes the job. Every dollar spent on the Opus 5.5 run bought a partial artifact that someone would still have to complete.

9.2 Where ceilings show up in ordinary work

Few teams formalize number theory, but the same discontinuity appears in work that matters commercially, in a milder form. The launch table shows Fable 5.2 at 64.9% on a simulated robotics benchmark against 39.4% for Opus 5.5, and 82.1% on WANDR agentic search against 72.3% - Anthropic. The 370-task coding suite shows it at a smaller scale: above 91% pass rate, only Fable 5.2 operates (section 5.3). And RLI is a ceiling story in economic form: on roughly one project in five, Fable 5.2 produces a client-acceptable deliverable that Opus 5.5 does not.

Customer reports at launch describe the same thing in qualitative terms. An engineer at Uber says Fable 5.2 "works until the job is actually complete instead of stopping at a plausible checkpoint", and one at Datadog that "you can just throw Claude Fable 5.2 at new, ambiguous systems it has never seen before" - Anthropic. Those are vendor-selected quotes, but they describe the property that matters for cost: whether the run ends with a finished result or a convincing partial one.

The principle generalizes beyond these two models. Cost per finished task is a step function of capability, not a smooth one. Below a task's difficulty threshold, a cheaper model's cost per finished task is effectively infinite, and above it, the cheaper model usually wins. The work of choosing a model is mostly the work of finding, for each kind of task you run, which side of the threshold the cheaper model is on.

9.3 The flip side: Fable 5.2 can also stop early

One caution keeps the ceiling story honest. Anthropic's own migration notes say that on long, multistep tasks, Fable 5.2 "sometimes ends a turn before the work is done", closing with a list of what remains or an offer to continue, and that this "occurs more often at low and medium effort" - Claude Docs. The fix is a system-prompt paragraph Anthropic publishes for exactly this purpose, telling the model to keep working through ordinary obstacles. An unattended agent that stops halfway is a failure in the break-even formula even when the model could have finished, so the low-effort Fable 5.2 settings that look cheapest in the charts need that prompt to deliver their numbers in production.

10. Speed, Fast Mode and the Cost of Waiting

Cost per task has a second dimension that does not show up on the invoice: time. An agent that takes longer to finish costs more when a person is waiting on it, and it costs throughput when it runs unattended.

10.1 How fast each model is

On Artificial Analysis' measurements, Fable 5.2 generates 93 to 103 output tokens per second depending on effort, against 103 to 115 for Opus 5.5, and takes 17.3 minutes per index task at high effort against 7.1 minutes for Opus 5.5 at medium - Artificial Analysis. Per token, the two are close. Per task, Fable 5.2 at its default is roughly two and a half times slower than Opus 5.5 at its default, mostly because it does more thinking before acting. Anthropic notes that Fable 5.2 is up to 30% faster than Fable 5.1 - Anthropic, so the gap to the previous premium model is narrower than the gap to Opus.

10.2 Fast mode: buying speed at double the price

Both models offer fast mode, which runs the same model on a faster inference configuration for up to 2.5x more output tokens per second, at twice the price: $16/$80 for Fable 5.2 and $8/$40 for Opus 5.5 - Claude pricing. The gain is in output speed, not in time to first token, and fast mode has its own rate limit, which Anthropic grants by default to organizations in the Start, Build and Scale usage tiers for both models - Claude Docs. On OpenRouter's live provider statistics, Anthropic's fast endpoint for Fable 5.2 was serving about 206 tokens per second on November 11 - OpenRouter. Caching multipliers stack on fast mode prices, and fast mode cannot be combined with the Batch API.

10.3 The same money buys speed or capability

Because Opus 5.5 in fast mode costs exactly what Fable 5.2 costs at standard speed, any team already willing to pay $8/$40 has a real choice to make. The right way to make it is to ask what the bottleneck is:

• A person is waiting (a developer pairing with an agent, a support agent drafting a reply, an analyst iterating): time is the cost. Opus 5.5 fast finishes the typical task several times sooner than Fable 5.2 standard, and if Opus 5.5 can do the task at all, that speed is worth more than the extra capability.
• Nobody is waiting (overnight runs, background agents, long autonomous jobs): time is cheap and failure is expensive. Fable 5.2 at standard speed, or through the Batch API at half price, is the better use of the money.
• Both matter (a production agent whose users wait and whose failures need a human): Fable 5.2 fast at $16/$80 is the only configuration that buys both, at four times Opus 5.5's standard price. That only makes sense on the high-value tail of the workload.

A rough calculation shows how quickly waiting dominates. At the median developer wage of $64.44 an hour - BLS, every ten minutes of waiting costs about $10.74, more than the entire token cost of most tasks in this guide. For interactive work, a model that finishes five minutes sooner has often paid for itself before the invoice is considered.

11. Failures That Still Send a Bill

Section 8 counted failures as tasks that simply did not succeed. Some failures are more specific, and each has its own price.

11.1 Refusals and safety reroutes

Both models run safety classifiers that can decline a request, and a decline before any output may or may not be billed depending on its category, but it counts against rate limits either way - Claude Docs. The two models behave differently here. Anthropic reports that Fable 5.2 blocks about 55% fewer requests than Fable 5.1 overall in early testing, about 60% fewer in cybersecurity and 40% fewer in biology - Anthropic. Opus 5.5, by contrast, routes most cybersecurity tasks to the older Opus 4.8 - Anthropic, and in Anthropic's own measurements it refused six biology questions per run on GPQA Diamond and was "nearly always" stopped by safeguards on four biology research tasks that a cheaper model answered - Claude Docs. A refused task is a failed task in the break-even formula, so teams in security, biology or adjacent fields should measure refusal rates on their own prompts before comparing costs. Organizations verified through Anthropic's cybersecurity and life-sciences programs can instead use Claude Mythos 5.2, which offers the same capabilities as Fable 5.2 to verified organizations only, at the same price - Claude release notes.

11.2 Breaking the cache

The identical $0.20 cache-read price only helps when the cache holds. When something early in a conversation changes (an edited system prompt, a changed tool list, a top-level effort change), everything after it is written again at the cache-write price. On Fable 5.2 that rewrite costs $10 per million tokens against $0.20 to read, a factor of fifty, which is why Anthropic notes that "the stakes are highest" on the Fable models. In its test on a cached conversation of about 100,000 tokens, editing the system prompt cost 25 to 50 times what the same text cost as a mid-conversation system message - Claude Docs. Any harness that rewrites its own history (summarizing old turns, re-ranking tools, injecting fresh context at the top) pays much more on Fable 5.2 than on Opus 5.5, and our guide to prompt caching for agents covers the patterns that keep the prefix stable.

Fable 5.2 adds a stricter version of the same problem. It enforces a prefix check on every account: if a harness edits the system prompt, the tools or an earlier message and then sends back a thinking block from a later turn, the request fails with a 400 error - Claude release notes. A beta setting lets the API drop the affected thinking blocks instead of failing, but Anthropic warns that dropping blocks "can raise output tokens", because the model has to redo the reasoning it lost - Claude Docs.

11.3 Overthinking, delegation and the long tail

Three more costs show up only in production. Max effort can lower scores: on FrontierCode 2.0, Fable 5.2 at max scored 45.6% for $44.70 against 49.1% for $14.19 at xhigh (section 3). Subagents can dominate a session's cost: Anthropic's prompting guide notes that how much Fable 5.2 delegates "depends on your harness and tasks", that in a product whose prompts invite delegation "it delegates readily", and that a tool description stating the cost of a subagent cut delegation by about a third with the same task success - Claude Docs. Our guide to running subagent fleets in Claude Code covers the same trade from the builder's side. And a few runs carry most of the spend: two of twenty WideSearch problems took 43% of the budget in Anthropic's run (section 4.3).

The defenses are the same on both models but matter more on the expensive one: workspace spend limits as a backstop, session budgets on Managed Agents, and a max_tokens large enough not to truncate work. On that last point, Anthropic found that raising max_tokens to 64,000 left only 7 of about 18,000 turns longer than the cap, without raising cost per solved task - Claude Docs. A truncated turn is the most wasteful failure there is: it bills every token and delivers nothing.

12. Subscriptions, Claude Code and Seats

Many teams never see a per-token bill, because they reach these models through a subscription or a tool that bundles them. The cost logic changes shape there, but it does not go away.

12.1 Claude plans

Fable 5.2 is available on the Pro, Max, Team and Enterprise plans - Claude on YouTube. Its launch came with temporary terms that are easy to mistake for permanent ones. From November 9 to November 16, 2026, Pro and standard Team seats got Fable models included up to 50% of their weekly usage limits; after that, Fable usage on those plans draws on usage credits. Max, Ultra, premium Team and premium legacy Enterprise seats instead received one to three usage resets depending on how long they had subscribed, valid until March 8, 2027, and a reset on the weekly limit restores Fable usage only - Claude Help Center. In the Claude apps and Claude Code, Fable 5.2 runs at medium effort by default, not the API's high - Anthropic.

The practical consequence for subscribers is that Fable 5.2 spends a limited allowance faster than Opus 5.5 does, so the cost-per-finished-task logic applies to quota instead of dollars. The same routing that saves money on the API (Opus 5.5 by default, Fable 5.2 for the hard tail) stretches a subscription further. Our Claude Code pricing guide covers the plans and limits in detail.

12.2 GitHub Copilot and other bundles

At GitHub Universe on October 28, GitHub made every Copilot feature available to GitHub Enterprise customers without a separate subscription, billed by the AI credits used - GitHub. Its individual plans now run from Free to Pro at $10, Pro+ at $39 and Max at $100 a month, with monthly credits of $15, $70 and $200 respectively at $0.01 per credit, and both Claude Fable 5.2 and Claude Opus 5.5 appear in its model list - GitHub. The plans page explains credits but does not list what each model consumes per request, so the only way to know what Fable 5.2 costs a Copilot user is to watch the credit meter, which is the subscription equivalent of measuring cost per task.

GitHub also introduced Copilot Fusion, which evaluates what a task needs and runs it across one or more models. GitHub reports that "Fusion Max scored within two points of Opus 5.5 Max at half the cost and 40% less time per task" - GitHub, a vendor claim but a telling one: the bundlers are building exactly the routing logic this guide argues for, so that individual developers stop choosing a model per request.

13. Routing Between the Two Models

If the right model depends on the task, the cheapest system uses both. The question is how to send each task to the right one without paying for the routing in latency, complexity or lost cache.

13.1 Escalation beats prediction

There are two ways to route: predict which tasks are hard and send them to Fable 5.2 up front, or escalate after a cheaper attempt fails. Prediction requires a classifier that knows the difficulty in advance, which is often the hardest part of the problem. Escalation only requires a failure signal: tests that fail, a validator that rejects, a judge that scores below a bar.

Anthropic measured the escalation policy within one model. On its SWE-bench Pro subset, running Opus 5.5 at low effort and re-running only the failures at high solved about 97% of tasks for about $0.17 per task, against 95.3% for $0.29 when everything ran at high - Claude Docs. The same logic extends across models: Opus 5.5 at medium first, failures escalated to Fable 5.2 at high. Because Opus 5.5 at medium solves the large majority of routine tasks, Fable 5.2's price applies only to the minority it needs to rescue, and the escalated tasks are precisely the ones where, by section 8's formula, the premium pays.

Two conditions apply, and Anthropic's guide states both: you need a failure signal that catches bad work, and every first-pass failure takes two runs' worth of wall-clock time, so the saving is paid for in latency on the failures - Claude Docs. Where neither a test nor a judge exists, escalation degrades into guessing, and a fixed choice per task type (from your measurements in section 14) is safer.

For a practitioner's view of the same routing decision, the How I AI podcast spent two days building with Fable 5.2 before recording, and its chapter at the 3:16 mark covers when to reach for Fable 5.2 instead of Opus 5.5.

The episode's hands-on tests (an animated marketing video made from a single post, assembly instructions for flat-pack furniture worked out from blurry photos, a re-architecture of a product intelligence pipeline) are the kind of open-ended, multi-step work where section 9 predicts the premium model earns its price. Its framing is a routing one rather than a wholesale switch: the episode description promises "how I'm thinking about routing tasks between Fable 5.2 and Opus 5.5 going forward", and lists a job the host still would not hand to Fable 5.2 alone (designing a website) - How I AI on YouTube.

13.2 What switching models mid-task costs

Escalating inside a single long conversation, rather than starting a fresh attempt, has two hidden costs. First, the cache does not carry over: caches are scoped to a model, so the first Fable 5.2 request writes the whole conversation at Fable 5.2's write price. For a 100,000-token conversation that is a one-time $1.00 at $10 per million, against $0.02 to read it on either model (our arithmetic from the pricing page). Second, reasoning does not travel in both directions: a conversation that moves onto Fable 5.2 keeps the reasoning from Opus 5.5, but one that moves from Fable 5.2 to any other model has its Fable 5.2 thinking blocks dropped - Claude release notes. Escalation is therefore cheapest one way, from Opus 5.5 up to Fable 5.2, and cheapest of all as a fresh attempt with a summary of what failed.

Within one model, there is a cheaper dial than switching: both models support changing effort mid-conversation with a per-message setting (a beta feature) that preserves the prompt cache, while a top-level effort change invalidates it - Claude Docs. Raising Opus 5.5 from medium to high for one hard step costs nothing in cache.

13.3 The advisor pattern

Anthropic also offers an advisor tool, in which a cheaper executor model consults a stronger one only for hard decisions. Its measurements are sobering: an Opus 5.5 executor at high with a Fable 5.1 advisor scored 90.1% on the internal coding suite for $2.92 per attempt, 1.7 points over the executor alone for about 2.1 times the cost, and where executors rarely consulted the advisor, the pairing scored no better - Claude Docs. Fable 5.2 alone at low now scores 88.9% on the same suite for $1.05 (section 5.3), so for this workload a single stronger model at low effort beats the two-model pairing on cost. Our broader guide to AI model routing compares the main routing designs across vendors.

13.4 Batch for everything that can wait

The simplest routing decision is by deadline rather than difficulty. Any Fable 5.2 work that can wait up to a day runs through the Batch API at $4/$20, Opus 5.5's real-time price (section 1.3). Overnight evaluation suites, report generation, document review and code audits can get the stronger model at no premium over the weaker one, as long as nobody needs the answer in the next few minutes.

For teams that would rather not run any of this machinery themselves, the alternative is a platform that makes the model decision internally: O-mega, for example, builds and runs a company's website, app, billing, content and admin through one AI, so model choice is the platform's problem rather than a routing table its users maintain. Whether that trade suits you depends on how much control over the per-task model you want to keep.

14. How to Measure Cost per Task on Your Own Work

Every number in this guide is somebody else's workload. The decision should rest on yours, and measuring it is cheaper than one month of guessing wrong.

14.1 The four steps

Anthropic's cost guide prescribes a four-step method that applies regardless of which models you compare - Claude Docs:

1. Pull real tasks from production logs, weighted like real traffic, and write an outcome check for each: tests pass, ticket closed, row count correct. Record cost per task beside the score.
2. Baseline across effort levels, not just the defaults, and plot score against spend for each model. Any multi-model setup has to beat the best single-model curve.
3. Add a second model or a routing policy only where the curve shows a gap that effort cannot close.
4. Run the winner in shadow on a slice of traffic before switching, and keep the evaluation running.

Two additions make the result decision-ready for this comparison. First, include the hardest tenth of your tasks as a separate slice, because that is where Fable 5.2 earns or fails to earn its premium and where most of the money goes. Second, log what each failure cost (minutes of human time, a rerun, a lost customer), because that is the H in the break-even formula and nobody else can measure it for you.

14.2 Pricing a task from the API's own usage data

The API reports every billable bucket in each response's usage object, so cost per task can be computed exactly rather than estimated. The function below prices one response on either model at list prices; summing it over every request of a task gives the task's cost. Prices are typed in as constants here because they are inputs you should update when Anthropic reprices.

# Price one Claude API response at list prices (USD per million tokens).
PRICES = {
    "claude-opus-5-5":  {"input": 4.00, "write_5m": 5.00,  "write_1h": 8.00,  "cache_read": 0.20, "output": 20.00},
    "claude-fable-5-2": {"input": 8.00, "write_5m": 10.00, "write_1h": 16.00, "cache_read": 0.20, "output": 40.00},
}

def response_cost(model: str, usage) -> float:
    p = PRICES [model]
    writes = getattr(usage, "cache_creation", None)
    w5 = writes.ephemeral_5m_input_tokens if writes else 0
    w1 = writes.ephemeral_1h_input_tokens if writes else 0
    cost = (
        usage.input_tokens * p ["input"]
        + w5 * p ["write_5m"]
        + w1 * p ["write_1h"]
        + usage.cache_read_input_tokens * p ["cache_read"]
        + usage.output_tokens * p ["output"]
    ) / 1_000_000
    if getattr(usage, "speed", "standard") == "fast":
        cost *= 2  # fast mode doubles every rate on both models
    return cost

The field names follow Anthropic's own pricing example, which reads uncached input, both cache-write durations, cache reads and output from usage, and its instructions say to apply fast mode rates when usage.speed is "fast" - Claude Docs. Thinking tokens are included in output_tokens, which is why effort shows up directly in this number. Log the result per task alongside the model, effort, number of turns, outcome and failure cost, and the comparison in this guide becomes a query over your own data. Our comparison of agent observability tools covers the tools that collect these traces for you.

14.3 What a good measurement looks like

A useful sweep for this decision is small: around 50 to 100 representative tasks, both models, three effort levels each (Opus 5.5 at medium, high and xhigh; Fable 5.2 at low, medium and high), two runs per setting to see the noise. At the per-task costs in this guide, that is typically a few hundred dollars, which is less than a single week of running the wrong model on a busy agent. Watch the cache-read share in the results: Anthropic's guidance is that a well-built loop reads over 80% of its input from the cache, and anything below that points to a cache break that will distort the comparison more than the model choice does. For background on why public benchmark scores rarely survive contact with a specific codebase, see our analysis of why AI coding benchmarks mislead.

15. The Market Around the Decision This Week

The Fable 5.2 versus Opus 5.5 choice does not happen in isolation. Four things that happened in the same fortnight change how much it matters and how long today's answer will hold.

15.1 The volume tier moved again

On the same day as Fable 5.2, Meta released Muse Ember, its smallest model, at $0.10 per million input tokens and $0.50 per million output tokens, with a 1M-token context window and up to 512K output tokens - Meta. Meta claims it "matches Haiku's best score at about a third of the cost" on the Artificial Analysis index, and positions it explicitly as a worker under its larger model: "Muse Wonder plans, Muse Ember handles the volume." Those are Meta's own figures, and its page notes that Ember's costs are estimates at proposed pricing.

For this guide, the relevance is structural rather than competitive. Neither Fable 5.2 nor Opus 5.5 should be doing high-volume, checkable bulk work at all. Anthropic's own measurements show Claude Haiku 5.5 reaching 85% on GPQA Diamond against 91% for Opus 5.5, at about a twentieth of Opus 5.5's cost per correct answer - Claude Docs, at a list price of $0.10 in. The planner-and-workers architecture that Meta describes is the third tier of the routing in section 13: the frontier model for the hard tail, Opus 5.5 for the bulk of real work, and a volume model for everything a checker can verify. Our coverage of Meta's Muse Wonder covers the top of that stack.

15.2 Always-on agents turn cost per task into a running cost

Always-on AI coworkers became a crowded category this autumn. Perplexity launched Teammates for Max subscribers on November 4: agents that work across teams, take hand-offs in Slack channels, and each run "in a separate environment, with browser sessions separate from other teammates" - Perplexity. Anthropic opened a research preview of Claude Duet on October 21, "a new app where Claude works as a proactive agent", and notes that it designed Duet around Claude Opus 5.5 - Claude. Our comparison of Claude Duet and ChatGPT Dots covers that category in depth.

That Anthropic built its own always-on agent on Opus 5.5 rather than its most capable model is the market's clearest vote on this guide's question. An agent that runs all day pays its cost per task thousands of times, so the default has to be the model that is cheapest per finished routine task, with the premium model reserved for the moments that need it.

15.3 Access is a cost too

Two events this fortnight are reminders that the cheapest model is worthless if you lose access to it. OpenAI notified SpaceX, after its acquisition of Cursor's parent company Anysphere, that it intends "to wind down our contract providing OpenAI models to Cursor, with a proposed shutoff date of November 12, 2026" - InfoWorld, which is tomorrow. Our explainer on SpaceX's purchase of Cursor covers the background. And the most capable models now often arrive gated: Google is making Gemini 4 Carbon available first to "a subset of cyber defenders" before general release - Google, while Claude Mythos 5.2 is limited to verified organizations.

For cost planning, this argues for keeping the harness portable: prompts, tools and evaluations that run on more than one model, so that a cost comparison can actually be acted on, and so that losing one model is an inconvenience rather than an outage.

15.4 Where the money in agents is going

Capital is following agents that do operational work end to end. Traversal, whose agents find out why company software breaks, raised $120 million at a $1 billion valuation in a round co-led by Kleiner Perkins, Redpoint and Khosla - The Next Web. Agents of this kind are exactly where the break-even formula favors the premium model: a wrong diagnosis during an outage costs far more than any token bill.

Anthropic's own public filing explains why it keeps cutting prices. According to one analysis of the S-1 filed on October 26, Anthropic's revenue was $16.3 billion in the first half of 2026, 80% of it consumption-based (API and other metered usage), with cost of revenue at 14.6% of revenue, and models released in the six months to September 30 produced over 80% of third-quarter revenue - sec-api.io. A business whose revenue comes mostly from metered usage of its newest models has every reason to keep lowering the cost per task of each new release, because cheaper tasks mean more tasks. Our guide to Anthropic's IPO covers the filing in more depth.

15.5 Outlook: the premium is a moving target

The price history points in one direction. The Fable line went from $10/$50 to $8/$40 with this release, and the Opus line from $5/$25 to $4/$20 with Opus 5.5, while cache reads fell faster still: from $1.00 on Fable 5 to $0.20 on Fable 5.2, and from $0.50 on Opus 5 to $0.20 on Opus 5.5 - Claude pricing. And each new Opus has arrived at roughly the previous Fable's capability: at its default medium effort, Opus 5.5 scored 52.5% on CursorBench against 51.8% for Fable 5.1 at max - Anthropic, three weeks after Fable 5.1 shipped.

If that pattern continues, the share of any team's work that sits above Opus's ceiling will shrink with each Opus release, while the frontier keeps opening new categories of work above it (formalizing a major proof with a thousand agents was not on anyone's task list a year ago). The durable strategy is therefore not "pick the right model" but "keep measuring which of your tasks sit above the cheaper model's ceiling", because that set changes every few months. For the broader question of whether newer models are actually smarter or just spending more compute per answer, see our analysis of what is driving benchmark gains.

16. Verdicts by Workload and the Bottom Line

The table below turns the evidence into defaults. Each is a starting configuration to measure against, not a rule, and the "why" column names the section that supports it.

The bottom line

The question "is Fable 5.2 worth twice the price of Opus 5.5?" has no single answer because it is the wrong question. Per token, Fable 5.2 costs twice as much, except on cache reads, where the two are identical. Per finished task, it costs anywhere from about 6% of what Opus 5.5 costs to nearly three times as much, depending on one thing: whether the task sits above or below the level that Opus 5.5 reaches at a reasonable effort setting.

Below that level, which is where most routine agent work lives, Opus 5.5 is the cheaper model by a wide margin, and Anthropic's own documentation, its own cost guide and its own always-on agent product all say so. Above it, Fable 5.2 is the cheaper model, sometimes dramatically, because it finishes work that Opus 5.5 either finishes only at maximum effort or does not finish at all, and a finished job is worth far more than the tokens it consumed. The break-even is not abstract: on the measured data, Fable 5.2 pays for itself wherever a failure costs more than somewhere between $9 and $81, which is less than an hour of a developer's time, and it never pays where Opus 5.5 at a higher effort setting already matches its success rate.

So the practical strategy is a short one. Default to Opus 5.5 at medium. Move along its effort curve before you change models. Measure cost per finished task on your own work, including the hardest tenth and the price of each failure. Send to Fable 5.2 the tasks where Opus 5.5's curve flattens below what you need, and run it at high, not max. Put everything that can wait through the Batch API. Then re-run the measurement when the next model ships, because on the evidence of this year, that will be in weeks, not months.

What this article rests on

Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.

• 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.
• Muse Ember (Meta): $0.10 in and $0.50 out per million tokens, cached input $0.004, 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.

In this topic: AI costs

• n8n vs Zapier vs Make: What AI Agents Really Cost (2026)
• Muse Code Pricing 2026: Plans, Real Limits, Wonder Full
• Codex Pricing 2026: Plans, Limits, Resets and Credits
• Prompt Caching: Cut AI Agent Bills 45% in 2026
• Grok Bot Pricing 2026: Real Costs, Limits, Alternatives
• GPT-6 Astra Pricing: Real Cost per Agent Task 2026
• Gemini 3.8 Flash: $0.58/Task for Agents 2026
• Cheapest LLM APIs for AI Agents: 2026 Price Table

What do AI models and agents cost, and how do you cut it? Every guide on it