Anthropic's Fable 5.2 Costs Four Times More Than Opus 5.5 While Delivering Identical Results
In direct testing of three coding and debugging tasks, Anthropic's newer Fable 5.2 model matched the performance of Opus 5.5 at roughly quadruple the cost and double the execution time.

When Anthropic unveiled Claude Fable 5.2 on November 9, the company claimed it surpassed Claude Opus 5.5 across nearly every measured capability. Yet in the same breath, Anthropic steered developers toward Opus for most coding and knowledge work, describing it as the "strongest daily driver." This contradiction prompted a closer examination: why would a company promote an inferior model, and does the less expensive option truly suffice?
Anthropic's own benchmarks show Fable 5.2 pulling ahead on FrontierCode 2.0, where it achieved 49.1% at high effort versus Opus 5.5's 45.5% at maximum effort. On FrontierSWE v2, Fable reached 69.9% compared with Opus's 62.3%. However, the pricing gap is substantial: Fable's standard API rates run at $8 per million uncached input tokens and $40 per million output tokens, double Opus's $4 and $20 respectively.
To understand whether the doubled expense justified the performance gains, three separate coding and agent-based tasks were executed on both models through Anthropic's API using default settings. Each model was graded on accuracy, token consumption, estimated cost, and execution speed. The tests deliberately avoided equal starting conditions: Fable 5.2 defaults to high effort while Opus 5.5 runs at medium effort, reflecting what developers encounter without manual tuning.
The Test Scenarios
Three distinct challenges were designed to evaluate different aspects of model capability:
- Cron scheduler: Models received a detailed specification for scheduling code and a subsequent change request, then were graded against a hidden suite of 50 test cases.
- Invoicing repository fix: Models operated as agents within a small invoicing library containing interacting bugs across rounding, discounts, tax, and shipping logic, plus one intentionally incorrect test case.
- Incident investigation: Models used terminal access to identify the root cause of a payments outage by examining logs, metrics, and deployment records containing misleading information.
When both models achieved perfect scores on initial versions, each test was made progressively more difficult and rerun twice more.
Cron Scheduler Results
This test evaluated whether a model could translate a detailed specification into working code and then incorporate changes without introducing errors. Three iterations increased in complexity:
- Version 1 covered standard cron schedules like 15-minute intervals or weekday mornings.
- Version 2 introduced complex rules such as "the weekday nearest the 15th" and "the last Friday of the month," plus a change request that reversed field interactions.
- Version 3 required manual handling of time zones and daylight saving time without relying on Python's built-in time zone library.
Both models achieved perfect 50 out of 50 scores across all three versions. The distinction lay in effort expended: Fable 5.2 generated two to three times more reasoning tokens than Opus 5.5 on every version, yet this additional reasoning produced no improvement in scores.
The extra reasoning did not raise Fable's score on any of the three versions.
Across all three scheduler iterations, Opus completed the work in 358 seconds at an estimated cost of $0.99, while Fable required 661 seconds and cost $3.29.
Detailed Performance Metrics
- Version 1: Fable 5.2 used 2 turns with 14,471 input and 18,732 output tokens (11,122 reasoning), costing $0.87 in 170 seconds. Opus 5.5 used 2 turns with 8,055 input and 9,431 output tokens (3,846 reasoning), costing $0.22 in 80 seconds.
- Version 2: Fable 5.2 used 2 turns with 20,215 input and 23,990 output tokens (14,627 reasoning), costing $1.12 in 226 seconds. Opus 5.5 used 2 turns with 14,090 input and 15,991 output tokens (6,695 reasoning), costing $0.38 in 131 seconds.
- Version 3: Fable 5.2 used 2 turns with 21,121 input and 28,254 output tokens (17,452 reasoning), costing $1.30 in 265 seconds. Opus 5.5 used 2 turns with 12,651 input and 17,205 output tokens (6,533 reasoning), costing $0.39 in 147 seconds.
Invoicing Repository Fix Results
This debugging task mirrors work agents perform for developers on a regular basis. Test difficulty escalated as follows:
- Version 1 contained bugs in rounding, discounts, tax, and shipping, plus one faulty test case.
- Version 2 added buy-two-get-one promotions, weight-based shipping, and refunds, each with associated bugs.
- Version 3 introduced currency conversion and invoice numbering, again with embedded bugs.
This test produced the most dramatic cost and time disparity between the two models. Both achieved perfect 50 out of 50 scores on all three versions, fixing the targeted bugs and correctly reporting the faulty test without modifying it. Opus 5.5 consumed fewer reasoning tokens across every version and completed each iteration in under one minute, while Fable 5.2 required between one minute 46 seconds and just under four minutes, costing eight times as much overall.
Once again, Fable's additional reasoning capacity failed to improve its score.
Detailed Performance Metrics
- Version 1: Fable 5.2 used 4 turns with 17,585 input and 11,511 output tokens (5,909 reasoning), costing $0.58 in 106 seconds. Opus 5.5 used 4 turns with 10,585 input and 2,975 output tokens (519 reasoning), costing $0.09 in 28 seconds.
- Version 2: Fable 5.2 used 6 turns with 88,697 input and 25,980 output tokens (11,820 reasoning), costing $1.39 in 223 seconds. Opus 5.5 used 4 turns with 13,938 input and 4,457 output tokens (777 reasoning), costing $0.13 in 39 seconds.
- Version 3: Fable 5.2 used 4 turns with 29,660 input and 24,020 output tokens (14,022 reasoning), costing $1.18 in 214 seconds. Opus 5.5 used 5 turns with 24,208 input and 6,013 output tokens (1,178 reasoning), costing $0.17 in 51 seconds.
Incident Investigation Results
This scenario rewards methodical analysis over rapid coding, suggesting it might favor Fable 5.2's more intensive reasoning approach. Test complexity increased as follows:
- Version 1 included misleading deployment records and a server with a clock running seven minutes behind.
- Version 2 added a clock correction mid-incident, request retries, a compressed log file, and duplicate log entries.
- Version 3 introduced a server logging in Chicago time and an unrelated error spike within the incident timeframe.
Both models scored perfectly (50 out of 50) across all three versions. Fable 5.2 required fewer turns in each version—9 to 11 compared with Opus 5.5's 12 to 14. Across all three versions, Fable's estimated cost reached $2.54 versus Opus's $0.91.
Detailed Performance Metrics
- Version 1: Fable 5.2 used 9 turns with 155,925 input and 14,309 output tokens (8,638 reasoning), costing $0.94 in 143 seconds. Opus 5.5 used 12 turns with 111,618 input and 7,405 output tokens (2,801 reasoning), costing $0.25 in 73 seconds.
- Version 2: Fable 5.2 used 11 turns with 168,913 input and 9,416 output tokens (3,551 reasoning), costing $0.68 in 105 seconds. Opus 5.5 used 13 turns with 188,846 input and 7,218 output tokens (2,518 reasoning), costing $0.32 in 82 seconds.
- Version 3: Fable 5.2 used 10 turns with 205,601 input and 11,887 output tokens (4,474 reasoning), costing $0.92 in 127 seconds. Opus 5.5 used 14 turns with 253,958 input and 7,598 output tokens (2,041 reasoning), costing $0.34 in 70 seconds.
Overall Findings
Performance scores remained identical across all nine test runs for each model. Fable 5.2 incurred costs approaching four times higher and required more than double the execution time.
Implications for Developers
These results suggest starting with Opus 5.5 for tasks of this nature. It matched Fable 5.2's accuracy while completing every version faster and at roughly one-quarter the estimated total cost.
This finding does not diminish Fable 5.2's capabilities. The tests were demanding but limited in scope. Anthropic positions Fable for more open-ended technical work requiring deeper reasoning. Since each model was tested at its API default settings, the comparison leaves unresolved how much of the performance gap stems from the different effort levels.
A practical strategy emerges: begin with Opus 5.5 and escalate to Fable 5.2 only when Opus fails to deliver satisfactory results.