Will It Fit? Arithmetic on Five Real Checkpoints

"Fit is three numbers: the weights at your bits, the cache at your context, and the working set the OS will actually give you. Speed is a fourth: the bytes a token touches, which for a mixture is a tenth of the file."

The Arithmetic

The code block applies the physics track to the store's five files. Weights at 4 bits: total parameters times 0.6 bytes — the lab measured 4.5 to 5.1 bits per weight on real 4-bit MLX checkpoints once scales and the unquantized tensors are counted, so 0.6 is the honest coefficient. Cache at 128K tokens: each architecture's KV bytes per token, derived from its config, times 131,072. The ceiling on the box: not 512 GB but the 498 GB the OS recommends the GPU take on office, measured in the GPU track. And the decode ceiling: 819 GB/s divided by the active bytes per token, because every one of the five is a mixture and the experts lesson's rule applies — a token reads its routed experts and the shared trunk, not the file.

Checkpoint	As shipped	At 4 bits	Cache at 128K	Fits 498 GB?	Active GB/token	Decode ceiling	Evidence
GLM-5.3 (753B, 40B active)	1,507 GB BF16	452 GB	12.5 GB	yes, 34 GB spare	24	34 tok/s	derived from the card and config
GLM-5.3-Flash (320B, 18B active)	643 GB BF16	192 GB	1.6 GB	yes; not a 192 GB Studio — 192 GB of weights against its 173 GB working set	10.8	76	derived
DeepSeek-V4.1-Flash (748B, 16B active)	510 GB FP4/FP8	510 as shipped	0.1 GB	no — 12 GB over; quantize the FP8 parts, or two Macs	9.6	85	derived
Kimi K3 (2.8T, 104B active)	1,561 GB MXFP4+BF16	1.4–1.7 TB	3.6 GB	no, not on two	62	13	derived
Qwen3.8-Flash-Next (180B, 6B active)	360 GB BF16	108 GB	3.3 GB	yes; any 128 GB Mac	3.6	228	derived

Three Verdicts the Table Changes

GLM-5.3 fits. The mouse track's rule of thumb — 85% of the box — said a 744B mixture (the card's count; the API's 753B includes the MTP head) does not, and at 512 × 0.85 = 435 GB it would not; the measured working set is 498, and 452 GB of weights plus 12.5 of cache leaves 34 to spare. The thumb was the honest instrument before the measurement; now the measurement is. DeepSeek-V4.1-Flash is the near miss: as shipped it is 12 GB over the working set, its experts already at 4 bits, so what stands between it and one Mac is the FP8 attention, shared experts and memory module — quantize those and it fits with room. And Kimi K3 fits nothing: 2.8 trillion parameters at 4 bits is 1.4 to 1.7 TB against 498, and two Macs' 996 does not reach it either; the store keeps it for a machine that does not exist. Qwen3.8-Flash-Next fits every 128 GB Mac in the house at 108 GB (not the 24 GB Air or the 64 GB mini) and its 6B active parameters give it the fastest ceiling on the table, 228 tokens per second — the experts lesson's promise, on a checkpoint the household actually holds.

What the Ceiling Column Is Worth

The ceilings are the physics track's upper bound, and the lab found its mixture reached 18–44% of the spec-based ceiling at batch one across three Macs, because a token that touches eight of 256 experts launches a kernel for each. GLM-5.3's 34 becomes perhaps 6 to 15 in practice; Qwen3.8-Flash-Next's 228 perhaps 40 to 100. Those are estimates from the lab's ratios on a different mixture, not measurements of these files, and the card should say so. What the column settles without measuring is the ordering and the shape: the model that fits the largest pool is not the model that decodes fastest, and the model that decodes fastest fits a laptop. A household choosing which checkpoint to quantize next reads this table, and the next lesson does the quantizing.

Code

will_it_fit.py — weights at 4 bits, cache at 128K, the measured working set, and the active-bytes ceiling·python

#!/usr/bin/env python3
"""Will it fit? Arithmetic on the five checkpoints the household's model store has landed,
as of 2026-09-15. Bytes on disk are the store's own catalog; parameter counts and active
counts are the model cards; 4-bit sizes are DERIVED at 0.6 bytes per parameter (the lab
measured 4.5-5.1 bits per weight on real 4-bit MLX checkpoints); KV per token is DERIVED
from each architecture's config. The ceiling is the measured GPU working set on a 512 GB
Studio: 464 GiB = 498 GB. Decode ceilings divide 819 GB/s by the ACTIVE bytes per token."""
WS = 498.0          # GB, office's recommended GPU working set
BW = 819.0          # GB/s, M3 Ultra spec
B_PER_PARAM = 0.6   # 4-bit with scales and a few unquantized tensors
CHECKPOINTS = [  # name, as shipped (GB, format), total params B, active params B (decode), KV bytes/token, note
    ("GLM-5.3",             1506.7, "BF16",           753,  40,  95232,  "MLA + sparse attention; 256 routed experts, 8 per token"),
    ("GLM-5.3-Flash",        642.7, "BF16",           320,  18,  11968,  "34 linear + 11 sparse-MLA layers; 288 experts, 8 per token"),
    ("DeepSeek-V4.1-Flash",  510.3, "FP4/FP8 mixed",  748,  16,  890,    "552B backbone + 196B Engram memory; experts already FP4"),
    ("Kimi K3",             1561.0, "MXFP4 + BF16",  2800, 104,  27648,  "69 linear + 24 MLA layers; 896 experts, 16 per token"),
    ("Qwen3.8-Flash-Next",   360.0, "BF16",           180,   6,  25344,  "125B + 51B n-gram embedding + 4B MTP; 512 experts, 10 per token"),
]
print(f"{'checkpoint':20} {'shipped':>9} {'format':14} {'4-bit GB':>8} {'fits 498?':>9} {'KV@128K':>8} {'active GB/tok':>13} {'ceiling':>8}")
for name, gb, fmt, total, active, kv, note in CHECKPOINTS:
    q4 = gb if "FP4" in fmt and "BF16" not in fmt else total * B_PER_PARAM      # DeepSeek ships mostly 4-bit already
    kv128 = kv * 131072 / 1e9
    fits = "yes" if q4 + kv128 <= WS else ("two Macs" if q4 + kv128 <= 2 * WS else "no")
    act = active * B_PER_PARAM
    print(f"{name:20} {gb:9.1f} {fmt:14} {q4:8.0f} {fits:>9} {kv128:8.1f} {act:13.1f} {BW/act:8.0f}")
print("\n'ceiling' = 819 GB/s / active bytes per token at 4 bits -- the experts lesson's arithmetic; real rates land at a fraction of it")
print("DeepSeek-V4.1-Flash as shipped (510 GB) exceeds the 498 GB working set by 12 GB: quantize the FP8 parts or it does not fit one Mac")

# checkpoint             shipped format         4-bit GB fits 498?  KV@128K active GB/tok  ceiling
# GLM-5.3                 1506.7 BF16                452       yes     12.5          24.0       34
# GLM-5.3-Flash            642.7 BF16                192       yes      1.6          10.8       76
# DeepSeek-V4.1-Flash      510.3 FP4/FP8 mixed       510  two Macs      0.1           9.6       85
# Kimi K3                 1561.0 MXFP4 + BF16       1680        no      3.6          62.4       13
# Qwen3.8-Flash-Next       360.0 BF16                108       yes      3.3           3.6      228

Exercise

Add one checkpoint you want to run to will_it_fit.py from its model card: total parameters, active parameters, KV bytes per token from its config. Use your own Mac's measured working set. Write the three verdicts on your card — fits at 4 bits, cache at your real context, ceiling from active bytes — and the practical rate you expect at the lab's mixture fraction.

Hint

If the card does not state active parameters, it is dense and active equals total. If KV per token is hard to derive, the physics track's kv_per_token.py reads it from the config; MLA and linear-attention layers cache far less than the head-count formula suggests.