Memory and attention

Fitting the weights is necessary and not sufficient. What decides how much hardware a deployment actually needs is usually the KV cache — the per-request memory that grows with conversation length and with how many requests are in flight — and models you could buy today differ on that by a factor of 368, from 0.89 MB to 327.68 MB per thousand tokens, with the parameter counts running the other way. This page shows which model does what, and where each one runs out.

Memory against context length

One line per model: how much accelerator memory that deployment holds as the conversation gets longer. The figures appear beside the names, not on top of the lines. Point at the chart to read every line at one context while you hover, or drag the slider beneath it — which arrow keys, Home and End also move — to hold a reading in place. A held reading survives the pointer wandering off, and moving the slider again replaces it. Escape releases it while the slider has focus — dragging the slider gives it focus, and moving it by keyboard means it already had it.

The deployment
Cache precision
Parallelism
Weight precision

Weights 1 of the 4 on the chart publishes no checkpoint size at all, so that figure rests on the parameter-count formula. The other 3 rest on published checkpoint sizes.

The axes
Longest context shown
Axis scale
Memory against context lengthA log-log chart of aggregate accelerator memory against context length, one line per selected model. Every figure it plots is also listed, as text, in the series list beside it.1 TB10 TB1K10K100K1M2.3 TBaggregate memorycontext length, tokens
  • Llama 3.1 405B runs out at 81K
  • GLM-5.2 runs out at ≤22K
  • Gemma 4 31B 1.48 TB at 262K
  • Nemotron 3 Ultra 550B-A55B ≥1.77 TB at 262K
  • System capacity DGX B300 · 2.3 TB estimated
  • Runs out here weights + cache meet capacity The context at which this system can no longer hold the checkpoint and the caches together.
  • Published window ends line stops, no extrapolation A memory figure past the window a publisher supports is a figure for a request nobody can make.
  • Before the first token 1.81 TB · GLM-5.2 4 of 4 start above zero at 32 concurrent requests, the next largest 1.36 TB, weights included.
  • Cache copies replicated on this system Under tensor parallelism.

Models on the chart 4 of 8

Grouped by publisher and sorted inside each group. Eight is how many colour-and-dash pairs stay separable on one chart, including in greyscale and for the commonest colour-vision deficiencies. Nothing is disabled: ticking a ninth model takes the slot of whichever has been on the chart longest, and every other line keeps the colour it had.

Cohere

DeepSeek

Google

IBM

InclusionAI

LG AI Research

Meta

MiniMax

Mistral AI

Moonshot AI

NVIDIA

Qwen

StepFun

Tencent

Xiaomi

Z.ai

34 of 34 models shown, from 16 of 16 publishers.

What each model does, and what it costs

Click a column heading to sort by it; where it does not fit, the table scrolls sideways.

Per-model figures on a single accelerator at a bf16 cache, so the comparison is between architectures rather than between topologies — with two exceptions worth knowing before reading the spread. Where a release fixes a layer group's width, this catalog records that width per group and Cache precision does not move it: every recurrent layer here keeps its state at fp32 and its convolution window at bf16, and DeepSeek V4.1 Flash's compressed latent and indexer keys are fp4. The two freeze opposite cells: a recurrent state is a per-sequence constant, so those models hold their "fixed per request" and halve their slope, while DeepSeek V4.1 Flash's pinned groups are per-token, so it halves its constant and holds its slope. "Per 1,000 tokens" is the marginal cost once every sliding window has filled; "fixed per request" is what a sequence costs on top of that once everything has settled — saturated windows plus any recurrent state. It is not the cost before the first token, because the two halves arrive at opposite ends: a recurrent state is there from the first token, a saturated window only once the sequence is long enough to fill it. For a purely windowed model the column is a real figure and the cost at zero tokens is zero. The Weights column follows the Weight precision control above, and marks with ≈ any figure not read off a checkpoint published at that width. Every figure in it carries the catalog’s 20% runtime overhead allowance on top of the checkpoint — what a deployment has to hold, which is more than what it downloads.

Attention
Llama 3.1 405B Meta · retiredGrouped-query attention, every layer The design current models are moving away from: 126 layers each storing full keys and values, at half a megabyte per token. official claim cache estimated Meta AI ↗Meta ↗DeepSeek AI (ISCA '25) ↗516.1 MB0 MB≈972 GB
Hunyuan Hy3 TencentGrouped-query attention, every layer Does nothing special about cache: 80 layers each store full keys and values, so long context costs more here than anywhere else in this catalog. official claim cache estimated Tencent (Hugging Face) ↗327.68 MB0 MB≈708 GB
Granite 4.2 30B IBMGrouped-query attention, every layer 64 layers each store full keys and values for 8 key-value heads. Nothing about the design reduces what long context costs, which is why a 30B model here caches most of what a 295B one does. official claim cache estimated IBM (Hugging Face) ↗262.14 MB0 MB≈70.3 GB
MiniMax-M3 MiniMaxMiniMax sparse attention over grouped-query attention Attends to only the 16 most relevant 128-token blocks, which cuts the arithmetic — but every token still has to be kept, so the cache itself is a full grouped-query cache. official claim cache estimated MiniMax (Hugging Face) ↗122.88 MB0 MB1.04 TB
Qwen3.8-2.4T-A95B QwenHybrid: Gated DeltaNet (linear) with full gated attention every fourth layer Only 23 of its 92 layers keep a growing cache; the rest hold a fixed recurrent state that does not depend on how long the conversation is. official claim mechanism ↗ cache estimated Qwen (Hugging Face) ↗vLLM ↗SGLang ↗94.21 MB587.29 MB5.87 TB
GLM-5.3 Z.aiMulti-head latent attention with a sparse-attention indexer Compresses key and value into one small shared latent per token, so cache cost follows the latent width rather than the 64 attention heads the config appears to advertise. estimated mechanism ↗ cache estimated Z.ai (Hugging Face) ↗89.86 MB0 MB906.7 GB
GLM-5.2 Z.aiMulti-head latent attention with a sparse-attention indexer Compresses key and value into one small shared latent per token, so cache cost follows the latent width rather than the 64 attention heads the config appears to advertise. official claim mechanism ↗ cache estimated Z.ai (Hugging Face) ↗89.86 MB0 MB1.81 TB
Hunyuan Hy4-preview TencentMulti-head latent attention with a sparse-attention indexer, every layer Compresses keys and values into a 576-element latent per token, then selects which tokens to attend to with a learned indexer. The latent is why a 780B model caches less per token than 295B Hy3 does. official claim cache estimated Tencent (Hugging Face) ↗89.86 MB0 MB≈1.87 TB
K-EXAONE 2.0 750B-A37B LG AI ResearchGrouped-query attention on a three-tier window schedule Blends full-attention layers with 4,096- and 128-token windows, so most of the stack keeps only a small fixed block. official claim mechanism ↗ cache estimated LG AI Research (Hugging Face) ↗81.92 MB46.66 MB≈1.8 TB
Gemma 4 31B GoogleSliding-window attention, five local layers to every global one Five layers in six only look back 1,024 tokens, so their cache stops growing there. Only every sixth layer pays the full price of a long context. official claim mechanism ↗ cache estimated Google ↗Google (Hugging Face) ↗Google (Hugging Face) ↗Sebastian Raschka ↗81.92 MB838.86 MB75.1 GB
Mistral Large 3 Mistral AIMulti-head latent attention Compresses key and value into a single 576-element latent per token per layer, independent of its 128 attention heads. official claim mechanism ↗ cache estimated Mistral AI (Hugging Face) ↗70.27 MB0 MB817.8 GB
Kimi K2.6 Moonshot AIMulti-head latent attention (MLA) on all 61 layers Every layer compresses its keys and values into one 576-element latent, so the cache grows with context but at a fraction of what 64 attention heads would cost. official claim cache estimated Moonshot AI (Hugging Face) ↗70.27 MB0 MB714.2 GB
Qwen3.8-27B QwenHybrid: Gated DeltaNet (linear) with full gated attention every fourth layer Only 16 of its 64 layers keep a growing cache. The other 48 hold a fixed recurrent state, which is why a 27B model can advertise a 262,144-token window. official claim mechanism ↗ cache estimated Qwen (Hugging Face) ↗vLLM ↗SGLang ↗65.54 MB153.94 MB66.7 GB
Qwen3.6-27B QwenHybrid: Gated DeltaNet (linear) with full gated attention every fourth layer Only 16 of its 64 layers grow with context; the other 48 hold a fixed recurrent state. official claim mechanism ↗ cache estimated Qwen (Hugging Face) ↗Sebastian Raschka ↗vLLM ↗SGLang ↗65.54 MB153.94 MB66.7 GB
MiMo V2.5 Pro XiaomiSliding-window attention with a 128-token window, six local layers to every global one Sixty of its seventy layers remember only the last 128 tokens, leaving ten to carry the whole long-range context. official claim mechanism ↗ cache estimated Xiaomi (Hugging Face) ↗51.2 MB39.32 MB1.24 TB
Llama 4 Maverick MetaGrouped-query attention with interleaved chunked attention (iRoPE) Most layers attend only within a chunk of the sequence, with a periodic full-attention layer carrying long-range context. official claim cache estimated Meta (Hugging Face) ↗49.15 MB1.21 GB963.8 GB
Step 3.7 Flash StepFunGrouped-query attention, 12 global layers and 33 with a 512-token window Every layer stores full keys and values for 8 key-value heads. Three quarters of them forget anything older than 512 tokens, which is what keeps a 200B model's long context affordable. official claim cache estimated StepFun (Hugging Face) ↗49.15 MB69.21 MB483.3 GB
Command A+ (05-2026) CohereSliding-window attention, three local layers to every global one Three layers in four only look back 4,096 tokens. Past that point just a quarter of the stack is still growing. official claim mechanism ↗ cache estimated Cohere (Hugging Face) ↗32.77 MB402.65 MB525 GB
Qwen3.5-397B-A17B QwenHybrid: Gated DeltaNet (linear) with full gated attention every fourth layer Fifteen growing layers out of sixty, at two key/value heads each — 30 MB per thousand tokens for a 397B model. official claim mechanism ↗ cache estimated Qwen (Hugging Face) ↗vLLM ↗SGLang ↗30.72 MB192.06 MB968.2 GB
Kimi K3 Moonshot AIHybrid: Kimi Delta Attention (linear) with Gated MLA every fourth layer Three quarters of its layers keep a fixed-size state that never grows with context; the rest cache a compressed latent. That is how a 2.8T model offers a million tokens. official claim mechanism ↗ cache estimated Moonshot AI (Hugging Face) ↗LMSYS Org ↗vLLM ↗SGLang ↗27.65 MB449.37 MB1.87 TB
Qwen3.8-Flash-Next QwenHybrid: Gated DeltaNet (linear) with sparse full attention every fourth layer Three quarters of its layers keep a fixed-size state; the rest cache normally and add a small index of which blocks are worth re-reading. official claim mechanism ↗ cache estimated Qwen (Hugging Face) ↗Hugging Face ↗vLLM ↗SGLang ↗27.65 MB115.64 MB432 GB
MiMo V2.5 XiaomiSliding-window attention with a 128-token window, roughly four local layers to every global one Most layers remember only the last 128 tokens, so their cache is a small fixed block rather than something that grows. official claim mechanism ↗ cache estimated Xiaomi ↗23.04 MB25.56 MB378 GB
Mistral Small 4 (119B) Mistral AIMulti-head latent attention, every layer Compresses keys and values into a 320-element latent per token on all 36 layers, with no sliding window anywhere. Narrower than any other latent model here. official claim cache estimated Mistral AI (Hugging Face) ↗23.04 MB0 MB145.1 GB
Qwen3.6-35B-A3B QwenHybrid: Gated DeltaNet (linear) with full gated attention every fourth layer Ten growing layers out of forty, and only two key/value heads on each, so context is unusually cheap for its size. official claim mechanism ↗ cache estimated Qwen (Hugging Face) ↗vLLM ↗SGLang ↗20.48 MB64.39 MB86.3 GB
GLM-5.3-Flash Z.aiHybrid: Kimi Delta Attention (linear) with sparse absorbed-MLA every fourth layer Three quarters of its layers keep a fixed-size state, and the quarter that does cache per token caches a compressed latent plus a small index of what is worth re-reading. official claim mechanism ↗ cache estimated Z.ai (Hugging Face) ↗Hugging Face ↗vLLM ↗vLLM ↗SGLang ↗16.92 MB147.62 MB394 GB
Gemma 4 E4B GoogleSliding-window attention with cache sharing across layers Short 512-token windows on most layers, and 18 of its 42 layers reuse another layer’s cache instead of keeping their own. official claim mechanism ↗ cache estimated Google ↗Google (Hugging Face) ↗Hugging Face ↗16.38 MB20.97 MB19.2 GB
Muse Glimmer 30B MetaSliding-window attention, three local layers to every global one Uses just two key/value heads and caps three layers in four at 2,048 tokens, which is what lets a 30B model target a laptop. official claim mechanism ↗ cache estimated Meta (Hugging Face) ↗Sebastian Raschka ↗13.31 MB81.79 MB71.5 GB
Nemotron 3 Ultra 550B-A55B NVIDIAMamba-2 state-space hybrid with periodic attention layers Only 12 of its 108 layers keep a growing cache. The rest hold a fixed-size state-space memory that does not depend on context length. official claim mechanism ↗ cache estimated NVIDIA (Hugging Face) ↗vLLM ↗SGLang ↗12.29 MB407.96 MB1.35 TB
Nemotron 3 Super 120B-A12B NVIDIAMamba-2 state-space hybrid with periodic attention layers Eight attention layers in eighty-eight. Everything else is a fixed-size recurrent state, so context is nearly free and the baseline is not. official claim mechanism ↗ cache estimated NVIDIA (Hugging Face) ↗vLLM ↗SGLang ↗8.19 MB170.23 MB296.7 GB
Ling-3.0-flash InclusionAIKimi Delta Attention on 35 of 42 layers, multi-head latent attention on 7 Five linear-attention layers for every one that keeps keys and values. The linear layers hold a constant state per sequence rather than a per-token cache, so context grows on a seventh of the depth. official claim cache estimated InclusionAI (Hugging Face) ↗vLLM ↗SGLang ↗8.06 MB75.98 MB306 GB
DeepSeek V4 Pro DeepSeekCompressed sparse attention interleaved with hierarchically compressed attention Compresses the cache four-fold on some layers and 128-fold on others, then attends to only the top 1,024 entries — plus an uncompressed 128-token sliding window in every layer. official claim mechanism ↗ cache estimated DeepSeek (Hugging Face) ↗DeepSeek ↗7.93 MB8 MB1.07 TB
Nemotron 3.5 Lightning 30B-A3B NVIDIAMamba-2 state-space hybrid with periodic attention layers Six attention layers in fifty-two — the flattest long-context curve in this catalog, at 6 MB per thousand tokens. official claim mechanism ↗ cache estimated NVIDIA (Hugging Face) ↗vLLM ↗SGLang ↗6.14 MB49.08 MB79 GB
DeepSeek V4 Flash DeepSeekCompressed sparse attention interleaved with hierarchically compressed attention Compresses the cache four-fold on some layers and 128-fold on others, then attends to only the top 512 entries — plus an uncompressed 128-token sliding window in every layer. official claim mechanism ↗ cache estimated DeepSeek (Hugging Face) ↗DeepSeek ↗5.54 MB5.64 MB200.3 GB
DeepSeek V4.1 Flash DeepSeekCompressed sparse attention over shared KV buffers, plus a sliding window per layer Four of the 43 layers store a compressed cache and 34 more read those same buffers. Every layer also keeps an uncompressed 128-token window, and an indexer selects the top 512 compressed positions. official claim mechanism ↗ cache estimated DeepSeek (Hugging Face) ↗DeepSeek (Hugging Face) ↗0.89 MB5.64 MB612.3 GB

A blank cost means this catalog does not model that model's cache. Two cases produce it, and both are deliberate: a model whose published material names its mechanism but never states how many layers use it, and a model whose configuration is not public. Guessing either would put a wrong number where a reader expects a measured one.

Why a tenth of the weights is not ten times the speed

Every mixture-of-experts release advertises a ratio: DeepSeek V4 Pro activates 49 billion parameters of 1.65 trillion, Kimi K3 activates 104 billion of 2.8 trillion. The obvious inference — that decoding must be twenty or thirty times cheaper than the size suggests — is true at batch size one and falls apart immediately afterwards.

The reason is that a decode step serves a whole batch at once, and each token picks its own experts. A step must read the union of everything its batch selected, and a union of independent draws saturates fast. The table below computes that union at the concurrency set above using E · (1 − (1 − k/E)^B) — the expected number of distinct experts touched when B tokens each choose k of E independently.

That is an expectation, not a minimum. Tokens that choose the same experts touch fewer of them, and at the extreme a step reads only the k experts every token in it chose, which is the active parameters however large the batch. The calculator's rate check uses that extreme for its lower bound, and only the lower bound may call a rate out of reach; this expectation is its estimate.

ModelRoutingExperts touched at 32Naive promise, × less trafficWhat is left
DeepSeek V4.1 Flash official claim DeepSeek (Hugging Face) ↗6 of 384152 40%47.7×2.51×
DeepSeek V4 Pro official claim DeepSeek (Hugging Face) ↗6 of 384152 40%33.7×2.47×
Kimi K2.6 official claim Moonshot AI (Hugging Face) ↗8 of 384188 49%31.3×2.02×
Qwen3.8-Flash-Next official claim Qwen (Hugging Face) ↗10 of 512240 47%30×2.1×
Kimi K3 official claim Moonshot AI (Hugging Face) ↗16 of 896393 44%26.9×2.23×
Qwen3.8-2.4T-A95B official claim Qwen (Hugging Face) ↗10 of 512240 47%25.3×2.09×
Qwen3.5-397B-A17B official claim Qwen (Hugging Face) ↗10 of 512240 47%23.7×2.08×
Llama 4 Maverick official claim Meta (Hugging Face) ↗1 of 12828 22%23.5×4.01×
DeepSeek V4 Flash official claim DeepSeek (Hugging Face) ↗6 of 256136 53%21.8×1.84×
GLM-5.3 official claim Z.ai (Hugging Face) ↗8 of 256163 64%18.8×1.55×
GLM-5.2 official claim Z.ai (Hugging Face) ↗8 of 256163 64%18.8×1.55×
MiniMax-M3 official claim MiniMax (Hugging Face) ↗4 of 12882 64%18.6×1.55×
GLM-5.3-Flash official claim Z.ai (Hugging Face) ↗8 of 288171 59%17.9×1.65×
Mistral Large 3 official claim Mistral AI (Hugging Face) ↗4 of 12882 64%16.5×1.54×
Command A+ (05-2026) official claim Cohere (Hugging Face) ↗8 of 128112 87%8.7×1.14×
The other four reasons, and what the measurements say

Batching is the biggest effect on the expert stack, but it is not the only one, and past about eight thousand tokens of context it is not even the largest term.

  1. Expert sparsity does not shrink attention. Sparsity applies to the expert layers. Attention weights are read in full every step, and so is the KV cache unless a model's attention selects among its tokens, and at long context they dominate: on published cost decompositions, attention is already several times the expert cost at 8,000 tokens and roughly ten times it at 32,000. That caps the best possible speedup at about 6× at 8K and under 3× at 32K — before any inefficiency at all. Step-3, decoding cost decomposed by model and accelerator ↗
  2. Each expert gets a tiny, ragged slice of the batch. At one token per expert a matrix multiply runs at a fraction of a percent of peak compute while saturating memory bandwidth. NVIDIA's own kernel team found that at decode batch sizes it is faster to compute all 256 experts densely and throw away the unselected results than to run a grouped multiply — doing thirty-two times the arithmetic wins. No source carried here.
  3. Spreading experts across accelerators costs a round trip per layer. The fix for the first two problems is expert parallelism, which pays for itself in dispatch and combine traffic on every layer of every step. DeepSeek's own analysis puts a ceiling near 67 tokens per second per user on that alone; their production system reports 20 to 22. DeepSeek at ISCA 2025, KV bytes and the all-to-all ceiling ↗
  4. Routing is not uniform, and the slowest rank sets the pace. Measured load skew runs four to sevenfold across ranks. Rebalancing experts is worth about 2.5× on decode throughput, which is another way of saying imbalance was eating most of it. No source carried here.

The clean measurement: on identical hardware, engine, precision and request shape, DeepSeek R1 — 37B active of 671B — delivers about 0.94× the per-GPU throughput of a dense 70B model. Sparsity delivered nothing in that configuration. A controlled academic study bracketing an MoE between dense models at both its active and total size found the same shape: matching the small dense model at batch 1, approaching the large one by batch 64. Epoch AI, MoE versus dense at inference ↗Lynx, the batch-size measurement ↗

The arithmetic saving is real — it is the bytes that are not. Everything above is about weight traffic, and the two are different resources. Each token still passes through only its own k experts, so the FLOPs per token stay sparse at any batch size; what stops being sparse is the number of distinct experts the step has to read, because a batch reads the union of what its tokens chose. Sparsity keeps its compute advantage and loses its bandwidth advantage.

Whether that saving is worth anything depends on which resource you have run out of. Decoding is memory-bound, so cheaper arithmetic buys nothing — the step is waiting on bytes, and published estimates put the crossover into compute-bound decoding at batches in the low thousands of tokens, well past what anyone runs. Prefill is compute-bound, and there the saving is immediate and proportional. That is why the workload shape matters more than the architecture: a summariser that reads little and writes at length spends its time in the regime where sparsity does nothing, while an agent replaying a 260,000-token transcript for a 1,100-token reply spends almost all of it in the regime where sparsity pays.

None of this makes sparsity useless. It buys training efficiency, and it buys quality per active parameter. What it does not buy is a proportional cut in serving cost — and the memory bill is set by total parameters regardless, because every expert has to be resident whether or not this step reads it.

Inference Economics · static, local-first calculationCatalog 0.8.1 · cutoff 2026-09-13 · app v0.8.1 · build 1c759ca