Contents · 16 min read
On November 9, 2026, Anthropic released Claude Fable 5.2, and by November 13 it was in my Claude Code sessions. On the evening of November 15, I asked it for something fun rather than a formal report: "I want Fable 5.2, meaning you, to use public information to work out Fable 5.2's parameter count, and what hardware a 'local deployment' would need, what it would cost, and how the model would perform: output speed, thinking time and so on." We talk in Chinese, so my messages and its first answers are translated here.
I gave it one rule: "I don't want to spend anything on testing. Use your imagination to design this test."
The question came out of my own shopping. I have been pricing a Mac to run AI models locally, as a private workstation next to the cloud models I use for coding. My candidates, an M5 Pro Mac mini and an M5 Max Mac Studio, sit about S$890 apart by my own estimate. I want it for Qwen3.8-27B, a model with 27 billion parameters. Parameters are the learned weights inside a model.
My current laptop is a 16 GB M4 MacBook Air. Plugged in, it runs a local Qwen model at about 17 tokens per second.
It doesn't know
Fable 5.2 read my notes and answered: "I don't know my own parameter count. A model can't introspect its own weights, and Anthropic has never published the number." Anthropic gives no size in its launch post, and a text search of the 5.2 system card turned up none either.
As Fable put it: "What this piece really is: the thing being measured weighs itself using public information. Every conclusion is an inference."
Every measurement and calculation below was done by Claude Fable 5.2 inside Claude Code on my laptop in Singapore on the evening of November 15, 2026, with zero spend on billed API calls. Gemini 4 Hydrogen independently re-checked the sources and collected the open-model dataset. This is one person's fun project, not research.
A stopwatch first
The one thing it can actually measure is its own speed. Claude Code keeps session files on my laptop with timestamps, token counts, and a timer for each thinking block. Fable wrote a script that read only those numbers—never the text—up to the evening of November 15.
It timed main-conversation phases with at least 200 tokens, leaving out sub-agent calls, and there were no fast-mode requests in my data. For each request, it checked both thinking speed on its own—without network or queue wait—and whole-turn speed from my message to the last block.
Medians, in tokens per second:
| Model, effort | Requests | Thinking | Whole turn |
|---|---|---|---|
| Fable 5.2, high | 114 | 92.6 | 94.9 |
| Fable 5.2, medium | 54 | 86.4 | 86.5 |
| Opus 5.5, high | 3,175 | 90.1 | 86.2 |
| Opus 5.5, medium | 9,246 | 89.3 | 89.4 |
In my Claude Code sessions, Fable 5.2 clocks about 90 to 95 tokens per second. That matches Artificial Analysis, which measures 97 to 106 tokens per second on the API.
It runs at practically the same speed as Opus 5.5, while costing twice as much at $40 per million output tokens against Opus 5.5's $20.
The catch is that all of this comes from my own sessions on one laptop in Singapore, my own coding workloads, client timestamps, and three days of Fable 5.2 against six weeks of Opus 5.5. Also, for reasons we couldn't pin down, the tokens generated after thinking read faster than thinking itself for both models.
All three stopwatch readings, with intervals
Each response gets three readings. Thinking: thinking tokens divided by the client's own timer for the thinking block. After thinking: the remaining output tokens divided by the time from the end of thinking to the last block. Whole turn: all output tokens divided by the time from the message that triggered the response to its last block. A reading needs at least 200 tokens in its phase. Medians, in tokens per second:
| Model, effort | Thinking | After thinking | Whole turn |
|---|---|---|---|
| Fable 5.2, high | 92.6 | 126.9 | 94.9 |
| Fable 5.2, medium | 86.4 | 106.2 | 86.5 |
| Opus 5.5, high | 90.1 | 140.0 | 86.2 |
| Opus 5.5, medium | 89.3 | 141.0 | 89.4 |
The 95% intervals around those medians:
| Model, effort | Thinking | After thinking | Whole turn |
|---|---|---|---|
| Fable 5.2, high | 91.0–97.9 | 123.6–127.7 | 93.8–97.6 |
| Fable 5.2, medium | 85.4–92.1 | 103.1–114.1 | 81.5–92.5 |
| Opus 5.5, high | 89.5–91.0 | 138.5–141.6 | 85.4–86.8 |
| Opus 5.5, medium | 88.7–90.1 | 140.5–141.7 | 89.0–89.7 |
What went into each row:
| Model, effort | Requests | Dates | Wait before thinking |
|---|---|---|---|
| Fable 5.2, high | 114 | Nov 13–15 | 1.1 s |
| Fable 5.2, medium | 54 | Nov 13 | 1.0 s |
| Opus 5.5, high | 3,175 | Oct 13 – Nov 13 | 1.9 s |
| Opus 5.5, medium | 9,246 | Oct 6 – Nov 13 | 1.3 s |
Standard speed, main conversation only, every Claude Code session on the laptop up to the evening of November 15, 2026.
Speed barely drops as the context grows. Thinking speed by how many context tokens the request carried:
| Context | Opus 5.5 | Fable 5.2 |
|---|---|---|
| Under 100K | 92.3 | — |
| 100–200K | 91.4 | 102.3 |
| 200–400K | 89.6 | 91.1 |
| Over 400K | 84.0 | 86.0 |
For Opus 5.5 that is a 9% drop from the shortest contexts to the longest. Fable 5.2 has too few responses in these buckets to say much.
Two rulers that broke
Before trusting any ruler on itself, Fable first tested each one on 20 open-weight models of known size, collected by Gemini and spot-checked against public pages.
First, it tried output price across the models sold by their own makers, which is the fair match for Anthropic, and the ruler broke. If you hide Kimi K3 and guess its size from its API price, the ruler predicts 486 billion parameters instead of the real 2.8 trillion.
That happens because list price reflects margin and positioning rather than hardware cost. On Nvidia B300 hardware, InferenceX estimates Kimi K3's compute cost near $0.15 per million tokens, against Moonshot's $15 output list price. So Fable's own high price tells us almost nothing about its size.
Next, it tried typical output speed, and found no relationship with size at all. Across the public models, providers seem to pick a speed of about 100 tokens per second by deciding how many users share a machine.
On Nvidia B300 hardware running Kimi K3, InferenceX measures 236 tokens per second for one user, dropping to 62.5 tokens per second when sixteen users share the machine. That means Fable's everyday speed in my sessions says nothing about its size.
How badly each ruler missed on models of known size
The test set is 20 open-weight models from 9 billion to 2.8 trillion parameters. "Miss" is how far off the ruler is, as a multiple, when each model is hidden in turn and predicted from the others.
| Ruler | Models | R² | Median miss | Within 2× | Worst |
|---|---|---|---|---|---|
| Maker's price | 11 | 0.12 | 5.8× | 2 of 11 | 17.9× |
| Cheapest price | 20 | 0.60 | 2.5× | 5 of 20 | 13.6× |
| Typical speed | 20 | 0.00 | — | — | — |
All three rulers try to predict total size. The first uses the output price of models sold by their own maker, the second the cheapest provider's output price. The speed ruler shows no relationship at all (correlation +0.02), so there was nothing to score.
Pointed at Fable's $40 per million output tokens, the first ruler says 1.8 trillion parameters, with a 90% band from 32 billion to 100 trillion.
One that sort of works
What did carry a signal was the top speed for a single user, because each token forces the chip to read the active weights from memory. Speed comes down to memory bandwidth—how fast the chip can read the weights—multiplied by real-world efficiency and divided by the bytes read per token. On Apple silicon at full power, real runs land between half and four fifths of that theoretical ceiling.
The home version of that rule shows up on my M4 MacBook Air. It runs a 9-billion-parameter Qwen model at 4-bit, which means each weight is squeezed to four bits so that more model fits in memory. Plugged in, it generates about 17 tokens per second.
During Fable's evening test, though, the laptop was on battery in Low Power Mode and dropped to 8.0 tokens per second. Conditions decide how close you actually get to the ceiling.
In a mixture-of-experts model, only part of the model works on any one token, and those are its active parameters. Kimi K3 has 2.8 trillion parameters in total, uses 104 billion of them on each token, and ships at 4-bit.
In InferenceX's single-user benchmarks, Kimi K3 hits 236 tokens per second on Nvidia B300 servers, 408 on Google's TPU v7, 457 on Nvidia GB300 machines and 926 on Nvidia's Vera Rubin.
Meanwhile, Anthropic says Fable 5.2's fast mode "speeds up token generation by up to 2.5 times", which, starting from about 100, would mean up to roughly 250 tokens per second.
Now assume Fable is served the same way, and that top speed falls in proportion as the active weights grow. To reach that fast-mode speed, Fable could have at most about 100 billion active parameters on B300 servers, or 170 to 190 billion on the TPU v7 and GB300.
So Fable uses at most about 100 to 200 billion active parameters per token, depending on the chips, and no more than 400 billion even on Vera Rubin. That is a ceiling. Nothing here gives a floor.
The ceiling on Fable's active parameters, depending on which chips serve it.
That ceiling could move roughly twice either way. Anthropic is reported to run on Amazon, Google and Nvidia chips and hasn't said which ones serve Fable, its software and precision may differ, and fast mode wasn't measured here. Kimi K3's figures also use multi-token prediction, and a trick like that on either side would loosen the bound.
If Fable has trillions of parameters, it cannot use all of them on each token.
A dense 3.5-trillion-parameter model would top out at about 7 tokens per second on an Nvidia B300 server, far below the speed measured here. Anthropic hasn't disclosed the architecture, so this is an inference, but most of the weights must stay idle per token.
The speed arithmetic
The rule: speed ≈ memory bandwidth × efficiency ÷ bytes of weights read per token. On Macs at full power it lands between 0.56 and 0.83 of the ceiling:
| Machine | Bandwidth | Measured | Share of ceiling |
|---|---|---|---|
| M4 Air, plugged in | 120 GB/s | 17.1–17.6 tok/s | 0.80–0.83 |
| M4 Air, Low Power Mode | 120 GB/s | 8.0 tok/s | 0.38 |
| M5 Pro | 307 GB/s | 10.42 tok/s | 0.56 |
| M5 Max | 614 GB/s | 24.0–27.4 tok/s | 0.65–0.71 |
The M4 Air ran a 9-billion Qwen model at 4-bit (5.63 GB). The M5 machines ran Qwen3.8-27B at 4-bit (16.6 GB).
In a datacenter, Kimi K3 (104 billion active parameters, 4-bit) was measured with one user at a time. If Fable is served the same way and top speed scales inversely with active weights, reaching 250 tokens per second caps its active parameters at:
| Hardware | Kimi K3, one user | Fable's ceiling |
|---|---|---|
| 8 × Nvidia B300 | 236 tok/s | 98 billion |
| 16 × Nvidia B200 | 216 tok/s | 90 billion |
| 16 × Nvidia GB200 | 233 tok/s | 97 billion |
| 8 × AMD MI355X | 223 tok/s | 93 billion |
| 16 × Google TPU v7 | 408 tok/s | 170 billion |
| 16 × Nvidia GB300 | 457 tok/s | 190 billion |
| Nvidia Vera Rubin | 926 tok/s | 385 billion |
By the same scaling, a dense 3.5-trillion model would top out at about 7 tok/s on 8 × B300, 14 on 16 × GB300 and 28 on Vera Rubin.
What others guessed
Since nothing measured on my laptop sees total parameters, Fable checked outside estimates. The most careful is Bojie Li's "Incompressible Knowledge Probes", which scores closed models on obscure facts. Version 1 in April 2026 put Claude Opus 4.7 at roughly 4.0 trillion parameters, until a pair of LessWrong authors caught an inflating scoring step and flawed questions that dropped it to 1.1 trillion. The paper's author agreed the method could not yet reliably estimate closed models.
In July, version 2 dropped that scoring step and recalibrated on open models, putting Claude Fable 5 at about 3.5 trillion parameters, with a 1.1 to 11.2 trillion band.
Even that comes with caveats: almost no calibration models sit at that scale, refusal-heavy models read as lower bounds, and it tested Fable 5 rather than the newer 5.2, which Anthropic calls "a step forward in general capabilities".
Other numbers are much thinner. In August 2026, Reuters relayed Financial Times "industry estimates" of about 5 trillion for Fable 5 and 8 trillion for Mythos 5, with no method. Anthropic's 5.2 post says "Claude Fable and Claude Mythos are the same underlying model". It doesn't say whether that held for the 5 generation. If it did, those two sizes can't both be right.
Blogs since April have called Mythos "10-trillion-parameter" with no traceable source. Meanwhile, a leaked March 2026 draft post, reported by Fortune and CSO Online, says only that it is "larger and more intelligent than our Opus models" and "very expensive for us to serve."
Fable's number

It can time itself. It can't weigh itself.
That left Fable with its final answer, and by its own account the total-size number is a soft guess.
My best guess is about 3.5 trillion parameters, and it isn't really mine. It is the knowledge-probe paper's estimate for Fable 5, the only outside number with a tested method behind it. I'd only stand behind it to within a factor of three: anything from 1 to 11 trillion wouldn't surprise me. I'm more confident about two smaller claims. Whatever the total is, only a small slice of it works on any one token, at most about 100 to 200 billion parameters. And the price tells you almost nothing about either number.
The total doesn't come from anything I measured. It comes from a paper whose first version was badly wrong, and which tested an earlier model than the one answering you. The only other number, from the press, came with no method. I can time myself. I can't weigh myself.
Published and inferred estimates of total parameter count on a log scale, with Kimi K3 as the known open-weight reference.
The shopping list
Because Fable 5.2's weights are not available and never have been, this shopping list is a thought experiment. Fable took Kimi K3's 4-bit file size as a yardstick, added 10% headroom, and priced M5 Ultra Mac Studios at their reported retail price next to Nvidia B300 servers:
| If the total is | Weights | Mac Studios | B300 servers |
|---|---|---|---|
| 2 trillion | 1.11 TB | 3 ($66,897) | 1 |
| 4 trillion | 2.23 TB | 5 ($111,495) | 2 |
| 8 trillion | 4.46 TB | 10 ($222,990) | 3 |
Each Mac Studio has 512 GB and costs US$22,299. Each B300 server has eight GPUs and 2.3 TB.
Fable's 3.5 trillion sits just under the middle row and still takes five Mac Studios, US$111,495. The catch is that Apple's own cluster claim stops at four machines, so scaling past that is untested.
Above the Macs, B300 servers are reported at $300,000 to $500,000 each, and a full Nvidia GB300 rack runs into the millions.
How fast would it be? The same bandwidth rule, checked against Jeff Geerling's Mac cluster and a reported Kimi K3 demo, puts those M5 Ultras somewhere between 7 and 19 tokens per second, depending on how close the active count is to that ceiling. Call it 12, roughly eight times slower than the API.

The same answer from the API and from five Mac Studios at home.
At that pace, a typical bit of thinking from my logs stretches from 3 seconds to 24 seconds.
The longest think in my sessions grows from about 2 minutes to 14.7 minutes.
And on Artificial Analysis's high-effort benchmark, waiting for the first answer token stretches from 27.5 seconds to 3.8 minutes, if that wait is all thinking.
Fable also replayed the research turn that planned this article. Including the time to read the long conversation context at local speeds, the whole turn would take 48 minutes instead of about 4.
For scale, running those Macs around the clock at Fable's $40 per million output price would take 7.4 years of nonstop output just to match their purchase price, counting output tokens only and no electricity.
Speed and waiting on the Mac cluster, in full
Predicted speed on M5 Ultra Mac Studios (1.2 TB/s each), assuming a cluster generates no faster than one machine's memory bandwidth allows:
| Active parameters | Read per token | Predicted speed |
|---|---|---|
| 104 billion | 52 GB | 12.9–19.2 tok/s |
| 150 billion | 75 GB | 9.0–13.3 tok/s |
| 200 billion | 100 GB | 6.7–10.0 tok/s |
The first row is Kimi K3's own count, and weights are at 4-bit. The same rule predicts 29–42 tok/s for Kimi K2 on M3 Ultra Macs, where Jeff Geerling measured about 30, and 9–13 tok/s for Kimi K3, where the one reported demo got 14.7 with a smaller build.
At a working figure of 12 tok/s:
| Wait | Tokens | On the API | At 12 tok/s |
|---|---|---|---|
| Typical think | 286 | 3 s | 24 s |
| Long think, top 10% | 2,321 | 24 s | 3.2 min |
| Longest think in 3 days | 10,594 | about 2 min | 14.7 min |
| First answer, high effort | — | 27.5 s | 3.8 min |
| First answer, max effort | — | 4.4 min | 36 min |
The thinks are from my sessions; the first-answer waits are Artificial Analysis's. The last two rows assume the whole wait is the model thinking at about 100 tokens per second.
What I'm left with
If you use Claude Code, Fable left a short read-only script you can run tonight. It reads only local session numbers—nothing leaves your machine—and matches the longer script it used for the numbers above to within 1 token per second.
On my laptop on November 15 it printed about 92 tokens per second for Fable 5.2 and about 90 for Opus 5.5:
import glob, json, os, statistics
rates = {}
for path in glob.glob(os.path.expanduser("~/.claude/projects/*/*.jsonl")):
for line in open(path):
try:
rec = json.loads(line)
except ValueError:
continue
if not isinstance(rec, dict) or rec.get("type") != "assistant":
continue
ms = rec.get("thinkingDurationMs")
if not ms or ms < 1000:
continue
usage = rec["message"].get("usage") or {}
tokens = (usage.get("output_tokens_details") or {}).get("thinking_tokens", 0)
if tokens >= 200:
rates.setdefault(rec["message"]["model"], []).append(tokens / (ms / 1000))
for model, values in sorted(rates.items()):
print(f"{model}: {statistics.median(values):.1f} tok/s over {len(values)} responses")
Four things still stay unknown: Fable's real total parameter count, which hardware serves it, fast mode's real speed (not tested because it costs money), and why the after-thinking rate reads higher than the thinking rate.
I am still choosing between the M5 Pro Mac mini and the M5 Max Mac Studio for my desk, and whichever one I buy will run a model about 130 times smaller than this guess.
