Fable 5.2 is a clear improvement on Fable 5 and Fable 5.1. Moving to it from either one gets you more working code, fewer findings and a stronger security profile. The trade is concurrency bugs, which keep growing, and cost, which rises with the extra reasoning.
Fable 5 and Fable 5.1 came out a few months ago and we had not evaluated either of them. So rather than review Fable 5.2 against a single predecessor, we ran all three together. If your team is still on Fable 5 or Fable 5.1, the useful question is what changes when you move to Fable 5.2. All three ran the same tasks and were analyzed together, so we can answer that directly.
How were the Fable models evaluated?
Models: Claude Fable 5, Fable 5.1 and Fable 5.2, all with thinking at high effort
Language: Java
Benchmark: the same Java benchmark we use for every model, covering HumanEval, MBPP and ComplexCodeEval. Each run covers 4,444 tasks. Of those, 544 come with executable tests, and the pass rate is measured on those 544. All 4,444 are analyzed for code quality and security, which is where every density figure below comes from.
Analyzer: SonarQube systematic code analysis, with all three runs analyzed on the same rule set. Complexity and code smell densities are per 1,000 lines of code (kLOC). Bug and vulnerability densities, and all category breakdowns, are per million lines (mLOC).
Three terms worth defining first:
- Cyclomatic complexity: counts independent paths through a function.
- Cognitive complexity: a SonarQube metric that weights nested and deeply branched logic more heavily, reflecting how hard the code is for a human to read.
- Severity: the impact level a finding carries, inherited from the rule that raised it. It describes how much a finding affects the software qualities Sonar measures. It is not a prediction of how likely that code is to reach production.
One note on reading the tables. Rates on small bases move a long way on very few findings. At these sizes a single finding is worth between 1.3 and 1.7 per mLOC. Wherever a rate is small, the finding count is in the text next to it.
How do Fable 5, 5.1 and 5.2 compare on key metrics?
Fable 5.2 has the best figure of the three for bugs, vulnerabilities, code smells and overall issues per line, as well as the highest pass rate. Fable 5.1 was a mixed step. Its security improved, but complexity and code smells went up before Fable 5.2 brought them back down.
Metric
Fable 5
Fable 5.1
Fable 5.2
Lines of code (total)
603,400
790,763
673,338
Comments density (% of LOC)
9.9%
6.9%
8.7%
Cyclomatic complexity per kLOC
223.86
239.47
221.77
Cognitive complexity per kLOC
124.10
141.84
124.63
Bug density per mLOC
608
563
557
Vulnerability density per mLOC
446
281
248
Code smell density per kLOC
16.38
17.15
12.79
Overall issue density per kLOC
17.44
18.00
13.60
Functional skill (pass rate)
87.68%
87.68%
90.26%
Missing completions
1.89%
0.74%
0.79%
What is the Fable family's functional pass rate?
Fable 5 and Fable 5.1 pass exactly the same 87.68%,. Fable 5.2 passes 90.26%.
For context, the Sonar LLM Leaderboard ranks models by this number. The highest pass rate currently on it is Claude Opus 5 at 88.60%, so Fable 5.2's 90.26% is above every model listed. Fable 5 and Fable 5.1 match Claude Opus 5.5 exactly. Pass rate comes from running the tests rather than from our analyzers, so it lines up with models measured at other times.
Missing completions tell a separate story. Fable 5 returned no usable code on 84 of the 4,444 tasks. Fable 5.1 cut that to 33 and Fable 5.2 sits at 35.
How much code do the Fable models generate?
Fable 5.1 wrote the most code of the three, almost a third more than Fable 5. Fable 5.2 pulled back from that, ending up about 12% above where Fable 5 started.
Function size barely moved. All three land between 7.6 and 8.1 lines per function, so the changes in volume come from writing more or fewer functions rather than longer ones. Fable 5.1 used 103,820 functions against 78,144 for Fable 5 and 82,680 for Fable 5.2.
Comments are a strength across the family. Comment density is 9.9% for Fable 5, 6.9% for Fable 5.1 and 8.7% for Fable 5.2. So anyone picking this code up later gets plenty of inline context from all three.
Does the code get more complex from release to release?
Fable 5.1 is the outlier. Cyclomatic complexity rose 7.0% to 239.47 per kLOC and cognitive complexity rose 14.3% to 141.84. Fable 5.2 brought both back: cyclomatic to 221.77, just under Fable 5, and cognitive to 124.63, just above it.
So the denser, more nested logic was specific to Fable 5.1. Fable 5.2 writes logic about as dense as Fable 5 did. Neither figure tells you whether the code works, but both indicate how much a reviewer has to hold in their head at once.
What is the Fable family's bug density?
Bug density came down at each step, from 608 per mLOC to 563 to 557. The counts read differently: 367 bugs for Fable 5, 445 for Fable 5.1 and 375 for Fable 5.2. Fable 5.1 had more bugs because it wrote more code, and Fable 5.2 ended up close to Fable 5 in bug count while writing 11.6% more lines.
Reliability severity per mLOC
Fable 5
Fable 5.1
Fable 5.2
BLOCKER
CRITICAL
MAJOR
280
221
247
MINOR
254
271
270
The top of the scale is where Fable 5.2 improved most, and this one is a real reduction rather than a denominator effect. Blocker bugs went from 20 in Fable 5 to 33 in Fable 5.1 and then down to 8 in Fable 5.2. Critical bugs went from 25 to 23 to 19.
Bug category
Fable 5/mLOC
Fable 5.1/mLOC
Fable 5.2/mLOC
Concurrency / threading
210
220
267
Null / data value
101
Performance / structure
Resource / stream leaks
Exception handling
API contract violation
Type safety / casts
Pattern / regex
Control flow mistake
Data structure
Uncategorized
Concurrency and threading is the largest bug category in all three, and it got worse with every release. Its rate and its count both rose each time, and it now makes up nearly half of Fable 5.2's bugs, up from about a third in Fable 5.
Most of the rest of the bug profile shrank by Fable 5.2. Resource leaks, exception handling, API contract violations and type safety issues all fell by around half or more, and control flow mistakes disappeared entirely.
Null and data value also grew between Fable 5 and Fable 5.2. Among the larger categories, it is the only one besides concurrency to do so. Performance and structure held roughly steady, and the remaining rows are small, with no more than a dozen findings in any of them.
So Fable 5.2's bug profile has become more concentrated. Fixing concurrency findings alone now addresses nearly half its reliability work. That cuts both ways. It makes remediation easier to target, and it puts the largest share of bugs in one of the hardest categories to reproduce. The rules that flag them are narrow and specific: double-checked locking, a lock not released on every path out of a method, synchronizing on a field that gets reassigned, a counter incremented on a volatile field, and calls to wait or notify made without holding the lock.
What security vulnerabilities do the Fable models generate?
This is the clearest improvement in the family. Vulnerability density came down at every step and ends 44% lower than Fable 5. The number of vulnerabilities fell too, so this isn't the same findings spread across more code.
Security severity per mLOC
Fable 5
Fable 5.1
Fable 5.2
BLOCKER
CRITICAL
278
215
160
MAJOR
MINOR
111
The most severe findings fell the furthest. Blocker vulnerabilities came down at every step, to just 4 in Fable 5.2, and critical came down at every step too.
Major and minor both dipped in Fable 5.1 and rose again in Fable 5.2. Minor still ends at about half of where Fable 5 started, while major ends above it.
Vulnerability category
Fable 5/mLOC
Fable 5.1/mLOC
Fable 5.2/mLOC
Insecure system resource handling
143
Cryptography misconfiguration
121
111
Inadequate error handling (I/O)
Injection attack
Hard-coded credentials
Certificate validation omissions
XML external entity (XXE)
Web API security misconfiguration
Path traversal injection
Uncategorized
The two largest categories, insecure system resource handling and cryptography misconfiguration, came down at every step. Together they still make up about two thirds of Fable 5.2's security findings, so they remain the place for a pipeline to look first. Crypto misconfiguration covers weak algorithms, insecure key sizes, and random number generators used in ways they should not be.
Two categories disappeared in Fable 5.2: certificate validation omissions and XML external entity. Hard-coded credentials is down to 3 findings and path traversal to a single one.
Three categories dipped in Fable 5.1 and came back up in Fable 5.2. Injection attack ends a little above where Fable 5 started, and web API security misconfiguration ends level with it. Inadequate error handling ends at less than half of where it started.
How maintainable is the Fable family's code?
Code smell density rose a little in Fable 5.1 and then fell sharply in Fable 5.2, ending about 22% below Fable 5. The number of smells fell too, so Fable 5.2 produces fewer smells than Fable 5 while writing more code.
Maintainability severity per mLOC
Fable 5
Fable 5.1
Fable 5.2
BLOCKER
CRITICAL
2,403
2,410
1,368
MAJOR
7,082
7,354
6,114
MINOR
6,387
6,796
4,730
INFO
449
520
515
Most of Fable 5.2's improvement is in the critical tier, which dropped by about 43%. Blocker smells stayed roughly level across all three.
Code smell category
Fable 5/mLOC
Fable 5.1/mLOC
Fable 5.2/mLOC
Collection / generics parameter type
6,032
6,974
5,164
Regex / pattern / string format
3,074
2,659
2,232
Design / framework best practices
2,310
1,959
1,522
Naming / style / documentation
1,203
1,390
1,222
Cognitive computational complexity
931
1,206
550
Dead / unused / redundant code
804
898
511
Assignment / field / scope visibility
751
914
673
Control / conditional logic
507
613
535
Deprecation / obsolete API
388
322
247
Uncategorized
375
214
110
Structure / architecture
Collection and generics is the largest category in all three, at around two in every five smells. Each category groups many rules, seventeen Java rules in this case, so the total does not tell you how much of it is any one kind of problem.
Cognitive computational complexity fell the most among the large categories in Fable 5.2, more than halving from Fable 5.1, which matches the drop in the cognitive complexity metric above. Structure and architecture is the one small row that rose, from about 5 findings in Fable 5 to 20 (30 per mLOC). How does code volume affect total findings?
Total findings
Fable 5
Fable 5.1
Fable 5.2
Bugs
367
445
375
Vulnerabilities
269
222
167
Code smells
9,886
13,564
8,615
All issues
10,522
14,231
9,157
Fable 5.1 is where volume and findings moved together. It wrote 31.1% more code and produced 35.2% more findings, so per line it had slightly more issues than Fable 5, with overall issue density up 3.2%. Its one clear gain was security, with fewer vulnerabilities despite the extra code.
Fable 5.2 broke that link. It wrote 11.6% more code than Fable 5 and still produced 13.0% fewer findings in total, so overall issue density fell 22.0%, from 17.44 per kLOC to 13.60. For a team, that means less to triage and less per line to worry about at the same time.
How do the Fable models compare on token usage?
Tokens
Fable 5
Fable 5.1
Fable 5.2
Input
2,069,584
2,078,466
2,078,466
Output
12,248,086
15,500,465
21,343,902
Of which reasoning
[~2.4M]
[~3.2M]
[~10.1M]
Total
14,317,670
17,578,931
23,422,368
Reasoning is counted inside output in these runs, so the total is input plus output. Input is nearly identical across the three, as you would expect from the same benchmark.
Output grew with every release, from 12.2 million to 15.5 million to 21.3 million. The reasoning line shows where the growth came from. Fable 5 and Fable 5.1 spent about a fifth of their output on reasoning. Fable 5.2 spent almost half, 10.1 million tokens, which is four times what Fable 5 used.
Per line of code, total output went from about 20 tokens in Fable 5 and Fable 5.1 to 31.7 in Fable 5.2. Take the reasoning out and what is left is the code and text the model returned, which stays at about 16 tokens per line in all three. So Fable 5.2 is not writing more per line. It thinks more before it writes, and its gains in pass rate and cleanliness come alongside that.
If you are estimating spend, plan on Fable 5.2 using 74.3% more output tokens than Fable 5 on this benchmark, with most of the increase in reasoning.
What does it cost to run the Fable models?
We priced each run at Anthropic's published API rates. Fable 5 and Fable 5.1 cost $10 per million input tokens and $50 per million output tokens. Fable 5.2 costs $8 and $40. Reasoning is billed as output.
Cost at list price
Fable 5
Fable 5.1
Fable 5.2
Total
$633
$796
$870
19%
20%
46%
Per task
$0.14
$0.18
$0.20
Across the family, the code got better and it cost more to produce. Fable 5.2 passes 14 more tasks than Fable 5, with 22% lower overall issue density and 44% lower vulnerability density, and it costs 37.5% more to run.
The two steps bought different things. Fable 5.1 cost 26% more than Fable 5 and passed the same number of tasks, though its vulnerability density dropped by more than a third. Fable 5.2 added another 9% and brought the higher pass rate and the drop in overall findings.
Most of the extra spend is reasoning, which cost $122 for Fable 5 and $403 for Fable 5.2. The lower per-token price softened that. At Fable 5's rates, the Fable 5.2 run would have cost $1,088, about 72% more than Fable 5 rather than 37.5%.
If you are estimating spend, start from the reasoning, not the amount of code you expect back. So far in this family, better results have come with a higher bill. Both are worth weighing when you choose a version.
What are the biggest risks of using Fable 5.2 generated code in production?
Concurrency is first. It is the largest bug category, it grew with every release, and it is now nearly half of Fable 5.2's bugs. These are among the harder findings to catch in review and to reproduce once they ship, and the rules that flag them are well covered by automated analysis.
Injection attack is second. It is a small category, but it doubled from Fable 5.1 and ends a little above Fable 5.
Null and data value bugs are third. They dipped in Fable 5.1 and then rose in Fable 5.2 to above where Fable 5 started, which makes them the second largest bug category after concurrency.
Security is the good news. Vulnerabilities fell at every release, blocker vulnerabilities are down to 4, and two categories went to zero.
Three takeaways:
- Fable 5.2 is the strongest of the three on correctness and issue density. It passes 491 of the 544 test-backed tasks, 14 more than Fable 5 and Fable 5.1, and its overall issue density is 22.0% below Fable 5.
- Security improved at every release. Vulnerabilities went from 269 to 222 to 167, and blocker vulnerabilities from 24 to 18 to 4.
- Plan for concurrency and cost. Concurrency bugs grew with every release and are now nearly half of all bugs. Running the benchmark cost 37.5% more than with Fable 5, but less than a tenth more than with Fable 5.1, so budget for the extra reasoning before you switch.
If you are on Fable 5 or Fable 5.1, move to Fable 5.2: you get more working code and fewer findings for a modest cost increase. Just do not read a higher pass rate as a reason to verify less. The bugs that remain are concentrated in concurrency, one of the hardest categories to catch by eye, so keep independent verification on every change the model makes.
Full evaluation results for all three Fable models, along with every other model we have measured, are on the Sonar LLM Leaderboard.












