In August, DeepSeek released the final version of DeepSeek-V4-Pro: 1.6 trillion parameters, with open weights anyone can download. Moonshot’s Kimi K3 reaches 2.8 trillion. Those are impossible-to-move model sizes. And yet, to write each word, V4-Pro uses only 49 billion: 3%.

It isn’t a one-off. Almost every large open model of 2026 works this way: DeepSeek, Kimi, Qwen, Llama 4, OpenAI’s gpt-oss and Google’s mid-size Gemma 4. They’re called Mixture of Experts, or MoE. Which makes the dumb question compulsory: if it only uses 3%, what does it want the other 97 for?

A quick note before going on: a language model doesn’t read words but tokens, which are pieces of words. I’ll say “word” here to keep things simple.

A kitchen full of specialists

A traditional LLM, the kind engineers call dense, is like one huge cook who makes every dish. For every word it writes, the whole model works: all its parameters, every time.

An MoE is a kitchen with lots of cooks and a head chef. An order (the word) comes in, the chef looks at what it’s about and hands it to two or three cooks. The rest take a break.

One huge cook versus a kitchen of specialistsOn the left, a dense model: a single huge cook who makes every dish, so the whole model works on every word. On the right, an MoE: the head chef takes the order and passes it to 2 of 8 cooks; the other 6 rest, but all 8 take up room in the kitchen. Working is compute; taking up room is memory.
The kitchen on the right has 8 cooks, like Mixtral. The kitchens of 2026 models have hundreds.

The analogy gives us the two ideas of this post:

  1. Each dish costs the work of two cooks, not the whole staff. That’s why you can hire many more without each dish getting more expensive. And more cooks means more knowledge stored in the model.
  2. The kitchen needs room for everyone, working or not. That room is the computer’s memory. Cooks on a break don’t get paid, but they still take up space.

In technical terms: the cooks who work are the active parameters, and the whole staff is the total parameters.

What happens inside

An LLM is a stack of layers, and each layer has two parts. The first is attention: each word looks at the others to understand the context. The second is a network that transforms each word on its own and holds most of the parameters. An MoE only changes the second part: it splits it into many small networks, the experts, and adds a router, which plays the head chef.

Inside one layer of an MoE modelA word enters the layer. First it goes through attention, which is shared: every word uses it. Then the router scores the 8 experts and picks 2, expert 2 with a weight of 60% and expert 7 with 40%. The other 6 do nothing with this word. The outputs of the two chosen experts are added with those weights and the result goes on to the next layer. This repeats in every layer, with a different choice each time.
One layer. The split (experts 2 and 7, 60% and 40%) is an example; the router decides for every word in every layer.

The router scores every expert, keeps the best ones (2 of 8 in Mixtral, 8 of 256 in DeepSeek-V3, 16 of 896 in Kimi K3) and blends their answers with weights. The choice is made for every word and in every layer: in the same sentence, each word can go through different cooks, and through others in the next layer.

A warning, because the name is misleading: “expert” doesn’t mean one knows medicine and another knows poetry. When the Mixtral authors looked at which experts got biology texts, philosophy texts and scientific papers, they found no split by topic. What they really split is weirder and more fun: I tell that story in MoE myths.

Why everyone uses it

Because learning gets cheaper. With the same compute budget, an MoE can have many more parameters, and more well-trained parameters make a better model. Google measured it in 2021 with the Switch Transformer: with the same resources it trained up to 7 times faster than its dense equivalents, and 4 times faster than the largest T5. In 2023, Mixtral 8x7B matched or beat Llama 2 70B, a dense 70-billion model, on every test in its paper, using only 13 billion per word.

The idea isn’t new: it shows up in a 1991 paper co-signed by, among others, Geoffrey Hinton. But until a few years ago it was hard to train without it going off the rails. Today it’s the norm:

Total parameters versus parameters working on each wordHorizontal bars on a linear scale, from smallest to largest model. The whole bar is the total parameters and the red part is what works on each word. gpt-oss-120b: 5.1 B of 117 B · 4.4%. Qwen3-235B-A22B: 22 B of 235 B · 9.4%. Llama 4 Maverick: 17 B of 400 B · 4.3%. DeepSeek-V3: 37 B of 671 B · 5.5%. Kimi K2: 32 B of 1,000 B · 3.2%. DeepSeek-V4-Pro: 49 B of 1,600 B · 3.1%. Kimi K3: 104 B of 2,800 B · 3.7%.
Linear scale on purpose: the red part, what works on each word, is barely visible. Data from each model's official card.

What about closed models, like Claude, GPT or Gemini? Their companies don’t publish the architecture, so nobody outside knows. The exception is Gemini 1.5 Pro, which its technical report describes as an MoE.

The fine print: computes like a small model, takes room like a big one

Here’s the catch, and it’s the one that most confuses people who want to run these models at home:

  • How much it computes depends on the active parameters. Computing little makes each word fast and cheap.
  • How much room it takes depends on the total parameters. Every expert has to be loaded in the graphics card’s memory, because the router may ask for any of them on the next word.

The clearest example is gpt-oss-120b, OpenAI’s open model: it uses 5.1 billion parameters per word, but it has 117 billion. It computes like a small model and takes room like a big one. If it fits on an 80 GB server GPU, that’s because its experts ship compressed to about 4 bits per parameter, not because it’s an MoE.

Try the calculator: pick a model or move the sliders, and see where it fits.

Calculator: how much memory, how much compute?

Bits per weight
How much of the model works on each word4 of 100 squares lit: 4.4% of the model works on each word. Memory taken by the weights, on a log scale, with three reference hardware sizesMemory: 59 GB. Needs an 80 GB server GPU.

4 of 100 squares lit: 4.4% of the model works on each word.
Memory: 59 GB. Needs an 80 GB server GPU.
Compute: about 10 GFLOP per word.

Computes like a 5.1 B dense model, but takes the memory of a 117 B one: 23 times more memory than compute.

117 B
5.1 B

4 bits is typical for running it at home; 16 is training precision. Weights only. The conversation's memory (the KV cache) comes on top and grows with every word and every user.

Two pairs are worth comparing because they come from the same family: Qwen3-32B (dense) versus Qwen3-30B-A3B (MoE), and Gemma 4 31B versus Gemma 4 26B A4B. Each pair takes almost the same memory, but the MoE computes 8 to 10 times less per word. Google presents its MoE as almost as fast as a 4-billion-parameter model.

If someone tells you their model “only uses 5B”, ask how much room it takes. It’s like bragging that your kitchen uses little gas without mentioning it fills an industrial park.

Still not seeing it? Watch the head chef hand out the work

Tap a word to see who the chef gives it to

The 8 cooks (experts) and how many words each one has

  1. Cook 1 · 3 words
  2. Cook 2 · 3 words
  3. Cook 3 51% 3 words
  4. Cook 4 49% 3 words
  5. Cook 5 · 2 words
  6. Cook 6 · 2 words
  7. Cook 7 · 1 words
  8. Cook 8 · 1 words

“The” goes to cook 3 (51%) and cook 4 (49%). The other six rest for this word.

The split is made up to show the idea: it comes from a fixed calculation on each word. In a real model, the chef learns how to split during training, in each of dozens of layers, and doesn't split by topic.

When to use which

If you use ChatGPT, Claude or any API, there’s nothing to decide: you pay per word, and the MoE savings, if any, already reach you in the price. The question matters when you’re the one running the model.

When a dense model pays off and when an MoE doesTwo-by-two chart. Horizontal axis: available memory, from little (one graphics card) to plenty (a server). Vertical axis: users at the same time, from few to many. Little memory and few users: dense. Little memory and many users: a small dense model, or better an API. Plenty of memory and few users: both work; an MoE gives more quality if it fits. Plenty of memory and many users: MoE, which is where it saves the most. Separately: if you use an API, you don't decide anything, because the MoE savings already reach you in the price.
Qualitative figure: the boundaries depend on your hardware and your traffic. Measure your own case.
If…BetterWhy
You have a single graphics card and little memoryDenseWith the same memory, the dense model uses all its parameters on every word
Few users, and you want every answer to take the same timeDenseNo router, no surprises: every word costs the same
You’ll retrain it (fine-tuning) on little dataDenseMoEs overfit sooner and are trickier to tune
Many users at once and memory to spareMoEThat’s where the compute saved per word turns into money
You want the most quality per unit of computeMoEIt stores more knowledge without paying for it on every word

Three things people get wrong

  • “It uses 5B per word, so it fits wherever a 5B model fits.” No: memory is set by the total parameters. gpt-oss-120b needs room for its 117 billion, plus the conversation’s memory on top.
  • “Each expert knows one topic.” No: in Mixtral, biology, philosophy and scientific-paper texts were spread across experts almost identically. What they actually do is in MoE myths.
  • “An MoE is always faster.” It computes less, yes. But with many users at once, each word asks for different experts, almost all of them have to be read, and the busiest expert sets the pace. Measure your own case, not the model card.

In three sentences

  1. A dense model uses everything it has on every word; an MoE stores a lot and uses little.
  2. Active → compute. Total → memory. Always ask for both numbers.
  3. Little memory and few users: dense. Lots of memory, lots of traffic or an API in between: MoE.

If you’re not sure what a parameter or a neuron is, start with the lesson Logistic regression or neural network?.

Now you know why Kimi K3 has 896 cooks and only sixteen work on each word. The rest wait in memory, eating up the GPU.

Sources

Checked on 5 October 2026. The calculator’s arithmetic is mine: memory = total parameters × bits ÷ 8; compute ≈ 2 operations per active parameter per word (Kaplan et al., equation 2.2).

How this post was made: from my notes, with Claude’s help for research and writing. The numbers come from the cards and papers above. Models change fast, so the table will go stale soon. The drawings are my own.