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, effortRequestsThinkingWhole turn
Fable 5.2, high11492.694.9
Fable 5.2, medium5486.486.5
Opus 5.5, high3,17590.186.2
Opus 5.5, medium9,24689.389.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, effortThinkingAfter thinkingWhole turn
Fable 5.2, high92.6126.994.9
Fable 5.2, medium86.4106.286.5
Opus 5.5, high90.1140.086.2
Opus 5.5, medium89.3141.089.4

The 95% intervals around those medians:

Model, effortThinkingAfter thinkingWhole turn
Fable 5.2, high91.0–97.9123.6–127.793.8–97.6
Fable 5.2, medium85.4–92.1103.1–114.181.5–92.5
Opus 5.5, high89.5–91.0138.5–141.685.4–86.8
Opus 5.5, medium88.7–90.1140.5–141.789.0–89.7

What went into each row:

Model, effortRequestsDatesWait before thinking
Fable 5.2, high114Nov 13–151.1 s
Fable 5.2, medium54Nov 131.0 s
Opus 5.5, high3,175Oct 13 – Nov 131.9 s
Opus 5.5, medium9,246Oct 6 – Nov 131.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:

ContextOpus 5.5Fable 5.2
Under 100K92.3—
100–200K91.4102.3
200–400K89.691.1
Over 400K84.086.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.

RulerModelsR²Median missWithin 2×Worst
Maker's price110.125.8×2 of 1117.9×
Cheapest price200.602.5×5 of 2013.6×
Typical speed200.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 most active parameters Fable could have and still reach 250 tokens per second, by the hardware Kimi K3 was measured on: 90 billion on Nvidia B200, 93 on AMD MI355X, 97 on Nvidia GB200, 98 on Nvidia B300, 170 on Google TPU v7, 190 on Nvidia GB300 and 385 on Nvidia Vera Rubin. Kimi K3 itself uses 104 billion.

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:

MachineBandwidthMeasuredShare of ceiling
M4 Air, plugged in120 GB/s17.1–17.6 tok/s0.80–0.83
M4 Air, Low Power Mode120 GB/s8.0 tok/s0.38
M5 Pro307 GB/s10.42 tok/s0.56
M5 Max614 GB/s24.0–27.4 tok/s0.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:

HardwareKimi K3, one userFable's ceiling
8 × Nvidia B300236 tok/s98 billion
16 × Nvidia B200216 tok/s90 billion
16 × Nvidia GB200233 tok/s97 billion
8 × AMD MI355X223 tok/s93 billion
16 × Google TPU v7408 tok/s170 billion
16 × Nvidia GB300457 tok/s190 billion
Nvidia Vera Rubin926 tok/s385 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

A sealed black block stands between a large stopwatch on one side and a broken bathroom scale and snapped rulers on the other.

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.

Log-scale comparison of total parameter estimates: the price ruler's 1.8 trillion with a band from 32 billion to 100 trillion, Kimi K3 known at 2.8 trillion, knowledge-probe v2 for Fable 5 at 3.5 trillion with a 1.1–11.2 trillion 90% band, Fable's own guess, borrowed from the probe, at about 3.5 trillion with a looser 1–11 trillion range, FT industry estimates at 5 trillion for Fable 5 and 8 trillion for Mythos 5, and unconfirmed 10 trillion blog claims.

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 isWeightsMac StudiosB300 servers
2 trillion1.11 TB3 ($66,897)1
4 trillion2.23 TB5 ($111,495)2
8 trillion4.46 TB10 ($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.

Two panels. Left: a person at a laptop, a full progress bar and a small hourglass. Right: the same person leaning back with a cup beside a stack of five linked computers, a nearly empty progress bar and a very large hourglass.

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 parametersRead per tokenPredicted speed
104 billion52 GB12.9–19.2 tok/s
150 billion75 GB9.0–13.3 tok/s
200 billion100 GB6.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:

WaitTokensOn the APIAt 12 tok/s
Typical think2863 s24 s
Long think, top 10%2,32124 s3.2 min
Longest think in 3 days10,594about 2 min14.7 min
First answer, high effort—27.5 s3.8 min
First answer, max effort—4.4 min36 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.

All notes