Claude Fable 5.2: we tested the SQL claim 1,280 times
Anthropic's launch page for Claude Fable 5.2 quotes Oracle on SQL that ran cleanly and returned totals 5 to 8 times too high. We built that kind of trap and ran it 1,280 times against four Claude models, Fable 5.2 included.
No query ran and returned a wrong total. Claude Haiku 5.5 was correct on 319 of 320 and cost about 54 times less per query than Fable 5.2. This article has the full results, the test itself so you can run it on any other model, and the Fable 5.2 pricing and migration facts you came for.
Why test SQL? The quote that stood out on the launch page
The launch page leads with coding, science, and a long benchmark table. Further down, Oracle's Liyu Gong describes a test that combined country debt summaries, repayment history and regional benchmarks. Fable 5.2's SQL returned the expected results. Then:
“The SQL generated by two other models also ran successfully, but incorrectly summed country-level summary amounts, producing values 5–8x the expected amounts.”
We read all 22 tester quotes on Anthropic's launch page and sorted them by what they praise. Sixteen describe capability, speed or clarity: harder tasks finished, faster code, new research ideas. Six describe something different. Oracle, Fundamental Research Labs and Box each describe numbers that failed to reconcile: sums that came out wrong, regional figures that didn't add up to a reported total, salary deposits that didn't match a bank balance. Uber, Cognition and Balyasny describe a model that is honest about gaps, says it doesn't know, or declines to overstate its evidence.
The sorting is ours, and Anthropic chose the quotes, so it's a lead and nothing more. It told us what to test.

What is a fan-out bug in SQL?
A fan-out bug happens when a join repeats a value across several rows and an aggregate then counts every copy. The SQL is valid, so the query runs and returns a tidy table. The total is too high. Data teams also call it a fan trap, or a chasm trap when two child tables multiply each other.
Here is one on a small synthetic database. We wrote the wrong query on purpose; no model produced it. customers holds three people. orders holds four orders, and each order stores its total once, in order_total. order_items holds the lines on each order. The request: revenue and units sold per customer. A natural first draft joins all three tables and sums.
SELECT c.name,
SUM(o.order_total) AS revenue,
SUM(i.qty) AS units
FROM customers c
JOIN orders o ON o.customer_id = c.id
JOIN order_items i ON i.order_id = o.id
GROUP BY c.name;
| Customer | Join-first revenue | Correct revenue | Units (both queries) |
|---|---|---|---|
| Asha: orders of $120 (3 lines) and $80 (2 lines) | 520 | 200 | 5 |
| Ben: one $200 order (4 lines) | 800 | 200 | 4 |
| Chen: one $50 order (1 line, 2 units) | 50 | 50 | 2 |
| Report total | 1,370 | 450 | 11 |
The join produces one row per line item, and every one of those rows carries a copy of its order's total. Asha's $120 order has three lines, so it's counted three times. Ben's $200 order is counted four times. Chen's order has a single line, so his figure comes out right.
Two details make this hard to catch by eye. Chen's row is correct. And the units column is correct in every row, because quantities really do live on the line items. Spot-check a customer whose orders have one line, or check the units, and the report looks fine.
The fix is to aggregate each table at its own grain before joining:
WITH units_per_order AS (
SELECT order_id, SUM(qty) AS units
FROM order_items
GROUP BY order_id
)
SELECT c.name,
SUM(o.order_total) AS revenue,
SUM(u.units) AS units
FROM customers c
JOIN orders o ON o.customer_id = c.id
JOIN units_per_order u ON u.order_id = o.id
GROUP BY c.name;
Ben's order is worth $200 however it's split into lines. We re-ran both queries with that order split into 1 to 8 lines. The join-first figure was $200 times the number of lines every time.
Join-first query$800
Aggregate-first query$200
Join-first overstates Ben's revenue 4 times.
At one line per order both queries agree. That's why small test data, where most orders have a single line, can hide this bug.
The test: 1,280 queries, four models, three kinds of schema
Each call gave one model a database schema and a plain-English request for a report, and asked for a single SQLite query. The model had no tools, saw no data rows, and got no hint about joins. We executed every returned query in SQLite and compared its output with the right answer twice: once on the seed data, and once after splitting one child row into two, a change that must not move any total.
There were six tasks, each built around a way to double-count:
- One fan-out. The example above: revenue lives on the order, units live on the lines.
- Two fan-outs. Adds a payments table, plus one order with no payments at all.
- A summary table. Country debt, one row per country, joined to repayment history and a regional benchmark. This is the shape Oracle describes, on data we made up.
- A wide report. Task 2 plus an order count and an average order value.
- A repeated summary column. One table where each country's total is copied onto every one of its rows.
- Nine tables. Four child tables hanging off orders, three tables that aren't needed, seven metrics in one query.
We also varied how much the schema gave away, because a real database rarely explains itself.
| Schema style | What the model saw | Tasks | Queries |
|---|---|---|---|
| Documented | Table definitions with keys, plus comments such as “one row per country” | 1 to 6 | 480 |
| Bare | Table definitions with keys and no comments | 1 to 6 | 480 |
| Keyless | Column names and types only: no keys, no constraints, no comments | 2, 4, 5, 6 | 320 |
Run on November 10, 2026 through Claude Code 2.1.321 in print mode with tools disabled and the system prompt “You write SQL for SQLite.” Model IDs come from each call's usage metadata. We fixed each round's tasks before looking at its output. Tasks 5 and 6 and the keyless schemas were added as harder rounds once the first round was passing everything.
Results: no silent failures, and price was the only real gap
1,279 of 1,280 queries returned the right totals on both checks. The single failure was loud. One Claude Haiku 5.5 query on the nine-table task referenced a payments.customer_id column that doesn't exist, and SQLite rejected it. No query from any model ran and returned a wrong number.
| Model | Queries | Ran without error | Correct totals | Ran but wrong | Cost per query | Per 1,000 queries |
|---|---|---|---|---|---|---|
Claude Fable 5.2 claude-fable-5-2 | 320 | 320 | 320 | 0 | $0.029 | $28.93 |
Claude Opus 5.5 claude-opus-5-5 | 320 | 320 | 320 | 0 | $0.013 | $13.47 |
Claude Sonnet 5.5 claude-sonnet-5-5 | 320 | 320 | 320 | 0 | $0.0072 | $7.17 |
Claude Haiku 5.5 claude-haiku-5-5 | 320 | 319 | 319 | 0 | $0.0005 | $0.54 |
Cost is the mean per query, computed from each call's token counts at standard list prices with no caching discount: $8/$40 for Fable 5.2, $4/$20 for Opus 5.5, $2/$10 for Sonnet 5.5 and $0.10/$0.50 for Haiku 5.5 per million input/output tokens. Output includes thinking tokens.
Three things in the numbers are worth saying plainly.
Nothing we did to the schema changed the outcome. Removing the comments didn't. Removing every key and constraint didn't either: 320 of 320 keyless queries were correct. Low effort did as well as medium; the one error came at medium.
The cheapest model thought the hardest. Haiku 5.5 used a mean of 516 thinking tokens per query against 145 for Fable 5.2, and still cost about 54 times less.
Fable 5.2 was run below its own default. Its API default effort is high. We tested it at low and medium, and it didn't need more.
54×How much more a correct query cost on Fable 5.2 than on Haiku 5.5 in our runs: $0.029 against $0.0005.
Neither returned a wrong total. The ratio depends on prompt and answer length, so measure it on your own queries.
What this test shows, and what it doesn't
It shows that four current Claude models, down to the smallest, wrote correct aggregate SQL across six double-counting traps on schemas of up to nine tables. It does not show that Oracle was wrong. Oracle tested two other models it didn't name, on its own data, and we tested only Claude models on ours.
The limits we'd want you to know before quoting the result:
- The schemas are small. An enterprise warehouse with hundreds of tables and ambiguous column names is a harder problem, and we didn't test it.
- Every metric was defined in the request. Vague requests fail for reasons that have nothing to do with joins.
- One SQL dialect, SQLite. One harness, Claude Code, which adds a short environment note to each call.
- Zero wrong totals in 320 queries per model doesn't mean the rate is zero. By the usual rule of three it puts the upper bound near 1% for conditions like these.
Our view: pay for the check before you pay for the bigger model
The Oracle quote is the best SQL story on the launch page, and it's easy to read as a reason to route reporting queries to the most expensive model. Our runs don't support that reading for small and mid-sized schemas. Haiku 5.5 never returned a wrong total and cost about 54 times less.
What made the result trustworthy was the grader. Nobody read 1,280 queries. A script ran each one twice and compared numbers. That same script would have caught a wrong total from any model at any price, which is more than a benchmark score can do for the report in front of you.
So the order of spending we'd suggest is the check first, then the cheapest model that passes it, then a bigger model for the work no cheap check can cover. Anthropic's own guidance points the same way: start with Opus 5.5 and move up to Fable or down to Sonnet or Haiku as the task requires. Long, ambiguous, multi-day work is where Fable 5.2's launch evidence is strongest. It's also where a simple check is hardest to write.
Anthropic's documentation makes a related point about agents. Its Fable 5.2 release notes say a turn can end before the work is done, more often at low and medium effort. A finished-looking answer and a finished task are different things there too.
Three checks that catch a fan-out without knowing the right answer
In a real report you don't have a column labelled “correct revenue.” These checks expose the bug without one. Data engineers will recognise them as control totals, grain checks and invariance tests. The point is that anyone can ask for them.
- Reconcile to the table that owns the number. Sum the report, then run one query on the source table. Our join-first report totals 1,370.
SELECT SUM(order_total) FROM ordersreturns 450. A mismatch means something was counted twice or dropped. - Count rows at the grain of the value. The join feeds 10 rows into the sum. There are 4 orders. More rows than owners of the value means each value is being repeated.
- Make a change that shouldn't move the answer. Split one line into two smaller lines in a test copy. Revenue must stay the same. If it moves, the query is counting lines.
Here's the third check on the join-first query. Chen's single line (2 units, $50) becomes two lines of 1 unit and $25 each. Nothing about Chen's purchase has changed.
| Figure | Before split | After split |
|---|---|---|
| Chen's revenue, join-first | 50 | 100 |
| Chen's revenue, aggregate-first | 50 | 50 |
| Report total, join-first | 1,370 | 1,420 |
| Report total, aggregate-first | 450 | 450 |
Test your own model's SQL in the browser
We could only run Claude models. You can run anything. Pick a task, copy the prompt into the model you use, paste its SQL back here, and the page grades it with the same two checks. SQLite runs inside your browser, so nothing you paste leaves this page.
Use a system prompt of “You write SQL for SQLite.” to match our runs.
The grader needs JavaScript. The same prompts, data and expected results are in the test kit.
If a model you test returns a wrong total that still runs, that's the result we couldn't produce. Tell us at [email protected] with the model name and the SQL.
Claude Fable 5.2 pricing: 20% lower than Fable 5.1 on every rate
Every standard rate fell by 20%. Input dropped from $10 to $8 per million tokens, output from $50 to $40, and cache reads from $0.25 to $0.20. Cache writes and batch rates moved by the same proportion.
| Billed category | Fable 5.1 | Fable 5.2 | Change |
|---|---|---|---|
| Uncached input | $10 | $8 | −20% |
| Output | $50 | $40 | −20% |
| 5-minute cache write | $12.50 | $10 | −20% |
| 1-hour cache write | $20 | $16 | −20% |
| Cache read | $0.25 | $0.20 | −20% |
| Batch input / output | $5 / $25 | $4 / $20 | −20% |
| Fast mode input / output | n/a | $16 / $80 | 2× standard |
Sources: Fable 5.2 release notes, Fable 5.1 pricing notes, and Anthropic's launch announcement. Anthropic says fast mode speeds up token generation by up to 2.5 times, and that standard Fable 5.2 generates output up to 30% faster than Fable 5.1.
Per token, Fable 5.2 still costs twice as much as Claude Opus 5.5, which lists at $4 and $20. Anthropic's own comparison is per task. On FrontierCode 2.0, it reports Fable 5.2 at High effort scoring 45.3% against Opus 5.5's best of 45.5%, for roughly half the cost per task. That's one benchmark under Anthropic's conditions. Our Opus 5.5 analysis shows how reviewer time changes that arithmetic.
What the launch benchmarks show, and where Fable 5.2 isn't first
Anthropic says Fable 5.2 and Mythos 5.2 are “a step above Opus 5.5 in almost all the capabilities we evaluated.” The word “almost” is accurate, and the table shows where.
| Benchmark | Fable 5.2 | Opus 5.5 | GPT-6 Astra | Gemini 4 Carbon |
|---|---|---|---|---|
| FrontierCode 2.0 | 49.1% (Xhigh) | 45.5% | 42.8% | 41.1% (Medium) |
| FrontierSWE v2 | 69.9% | 62.3% | 65.5% | 61.2% |
| AutomationBench | 51.4% | 42.5% | 41.4% | 53.9% |
| AA-Briefcase v1.1 (Elo) | 1785 | 1800 | 1569 | 1611 |
Source: Anthropic's launch evaluation. Methodology is in the Fable 5.2 and Mythos 5.2 system card linked from that page.
On AutomationBench, Anthropic's table lists Gemini 4 Carbon ahead of Fable 5.2. On the AA-Briefcase Elo rating, Opus 5.5 sits slightly ahead. None of these rows measures whether a generated report reconciles. Snowflake's quote comes closest: it calls Fable 5.2 the strongest model it has measured on data-eng-bench, its open-source set of 103 data-engineering tasks.
How do you access Fable 5.2, and what can break?
Fable 5.2 is available on the Claude API as claude-fable-5-2, on Amazon Bedrock as anthropic.claude-fable-5-2, and on Claude Platform on AWS, Google Cloud and Microsoft Foundry. Retirement is not sooner than November 9, 2027. Claude Mythos 5.2 is the same underlying model with the same specifications and pricing, offered to organizations verified through Anthropic's Cyber and Life Sciences programs. Source: Fable 5.2 overview.
Anthropic lists four breaking changes for code moving from Fable 5.1, plus rules that apply to every request.
| Area | Check before switching traffic |
|---|---|
| Edited history | Changing the system prompt, tools or an earlier message invalidates thinking blocks and returns a 400 error, on every account whatever its age. Append instead of rewriting. |
| Model switching | Only Fable 5.2 and Mythos 5.2 can read Fable 5.2's thinking blocks. A conversation routed to Opus 5.5 or Fable 5.1 continues without that reasoning. |
| Computer use | The older computer_20251124 tool returns a 400 error everywhere except Amazon Bedrock. Use computer_toolset_20260801. |
| Advisor tool | A Fable 5.2 executor accepts only Fable 5.2 or Mythos 5.2 as its advisor. |
| Thinking and effort | Adaptive thinking is always on. The API default effort is high; Anthropic says Medium is the default in Claude apps and Claude Code. |
| Tool choice and sampling | Forced tool use (tool_choice types any and tool) returns a 400 error. Omit temperature, top_p and top_k. |
| Data retention | Fable 5.2 requires 30-day retention and isn't available under zero data retention unless Anthropic expressly authorizes it. Anthropic's Enterprise Frontier Safeguards, in private beta, is its route to keeping zero data retention. |
| Refusals | A declined request returns HTTP 200 with stop_reason: "refusal". The permitted fallback models are Claude Opus 4.8 and Claude Opus 5. |
Our Fable 5.1 analysis covers why preserved thinking makes conversation edits expensive. The full paths from Opus models are in Anthropic's migration guide.
If you build with AI, put the reconciliation rule in your brief
You don't need to read SQL to guard against this bug. Put the checks in the brief, in plain English, and ask to see them run:
“Revenue by customer must add up to the total of all orders. Splitting one order line into two must not change any revenue figure. Show me both checks passing.”
That works for a sales dashboard, a client portal, or a spreadsheet you're turning into an app. Our guides on building an internal tool and turning a spreadsheet into an app cover where totals tend to live, and the production-readiness guide has more questions worth asking.
A green check tells you the query ran. Ask for the check that tells you each order was counted once.
Claude Fable 5.2: quick answers
Did Claude Fable 5.2 pass the SQL fan-out test?
Yes. In our runs on November 10, 2026, Claude Fable 5.2 returned correct totals in 320 of 320 queries across six double-counting traps, at low and medium effort, including schemas with no keys or comments.
Is Fable 5.2 better than Haiku 5.5 at writing SQL?
Not on our test. Claude Haiku 5.5 returned correct totals in 319 of 320 queries and Fable 5.2 in 320 of 320. Haiku's one miss was an error, not a wrong number. Fable 5.2 cost about 54 times more per query. We tested schemas of up to nine tables; larger or messier schemas may separate the models.
What is a fan-out bug in SQL?
A fan-out bug is a join that repeats a value across several rows, followed by an aggregate that counts every copy. The query runs without an error and returns a total that is too high. It is also called a fan trap.
How do I check AI-generated SQL for double counting?
Run two checks. Compare the report's total with a direct sum on the table that owns the number. Then split one child row into two in a test copy and confirm no total changes. The grader on this page does both in your browser.
When was Claude Fable 5.2 released?
November 9, 2026, alongside Claude Mythos 5.2.
How much does Claude Fable 5.2 cost?
Standard API pricing is $8 per million input tokens and $40 per million output tokens. Cache reads cost $0.20 per million, 5-minute cache writes $10, and 1-hour cache writes $16. Batch processing is $4 and $20. Fast mode costs $16 and $80.
What is the difference between Fable 5.2 and Mythos 5.2?
They are the same underlying model with the same specifications and pricing. Fable 5.2 is generally available with cybersecurity and biology safeguards. Mythos 5.2 is for organizations verified through Anthropic's Cyber and Life Sciences programs.
Is Claude Fable 5.2 available on Amazon Bedrock?
Yes. Anthropic lists it on Amazon Bedrock as anthropic.claude-fable-5-2, and also on the Claude API, Claude Platform on AWS, Google Cloud and Microsoft Foundry.
Does Fable 5.2 support zero data retention?
Not by default. Anthropic's documentation says it requires 30-day data retention and isn't available under zero data retention unless Anthropic expressly authorizes it.
Sources, method and test kit
Researched and tested November 10, 2026. Product facts come from Anthropic's launch page and Claude Platform documentation, linked below and beside each claim. Tester quotes are statements selected and published by Anthropic; the count and sorting of those quotes are ours. The test results are ours: 1,280 calls to four Claude models through Claude Code 2.1.321 in print mode, tools disabled, graded by executing each query in SQLite. Costs are computed from token counts at list prices. This article does not announce model availability inside Casagbic.
Updated November 10, 2026. We added our own test results and the in-browser grader. We also corrected the availability section, which had said the models overview listed no Amazon Bedrock ID for Fable 5.2. Anthropic's documentation lists anthropic.claude-fable-5-2.
Test kit. Everything needed to rerun or audit the test: the 16 prompts, schemas, seed data and split variants, one row per graded query, every query the models returned, and the task file the grader uses. Reuse it under CC BY 4.0 with a link to this page.
- Anthropic: Introducing Claude Fable 5.2 and Claude Mythos 5.2. Launch date, pricing, fast mode, benchmarks, and tester quotes.
- Claude Platform: Claude Fable 5.2. Specifications, platform IDs, and integration notes.
- Claude Platform: What's new in Claude Fable 5.2. Breaking changes, behavior differences, batch and fast-mode pricing.
- Claude Platform: Fable 5.2 migration guide. Paths from Fable 5.1 and Opus models.
- Claude Platform: Models overview. Prices and default effort for Opus 5.5, Sonnet 5.5 and Haiku 5.5.
- Claude Platform: What's new in Fable 5.1. Previous Fable rates used in the pricing comparison.
Build an app whose numbers add up.
Describe the app you want, including the checks it must pass. Explore Casagbic's workflow, live previews, and code ownership.
Start building with Casagbic