Why size is the whole story

What the number in the name means

Many model names carry a number. Qwen3-8B. Qwen3-0.6B. gpt-oss-20b. The B is short for billion, and the number counts the learned numbers inside.

Qwen says Qwen3-8B holds 8.2 billion of them. Those parameters take up room, so the count sets how big the file is.

You can see it on the download page. The Qwen3-8B files add up to about 16 GB. DeepSeek publishes a model with 671 billion parameters, and its files add up to about 689 GB.

One family often comes in a ladder of sizes. The Qwen3 report describes a range from 0.6 billion parameters up to 235 billion. Same team, same recipe, different rungs.

Backed by Qwen3-8B model card, Qwen3-8B repository files, Qwen3 Technical Report, DeepSeek-R1 model card, DeepSeek-R1 repository files.

Reading it off the page

All of this is printed on the model's own page, and it is worth learning to read one.

The Qwen3-8B card opens with a short block of facts. One line reads "Number of Parameters: 8.2B". Another gives its context length as 32,768 tokens natively, which is how much text it can hold at once.

Then there is a Files tab. Qwen3-8B lists five model files, named model-00001-of-00005.safetensors up to the fifth. Together they come to about 16 GB.

Now the mistake, and it is the one that wastes a whole evening. People read 8B and plan for 8 GB. The download is twice that.

The reason is in config.json, which is 728 bytes of readable text. It says the numbers are stored as bfloat16: sixteen bits, or two bytes, for each one. Two bytes across 8.2 billion parameters is roughly the 16 GB on the page.

So the rule is short. Never guess a model's size from its name. Open the Files tab and add up what is actually there.

Backed by Qwen3-8B model card, Qwen3-8B repository files, Qwen3-8B config.json.

Bigger usually knows more

This has been measured. A 2020 paper, Scaling Laws for Neural Language Models, studied how well models predict text.

It found that error falls in a steady, predictable pattern as you add parameters, training data and computing power. The pattern held across a very wide range of sizes.

Read that as a trend, not a promise. It says what happens when you scale one approach up. It does not tell you that any 30B model beats any 8B model.

How a model was trained counts for as much. Microsoft built phi-4 at 14 billion parameters around the idea that a small model can be strong if its training data is good enough.

So a bigger number is meaningful inside one family. Across different makers, it settles very little.

Backed by Scaling Laws for Neural Language Models, Phi-4 model card.

Bigger needs more room

While a model runs, its numbers have to be held in your computer's memory. That is the wall you hit first, and the next lesson is about it.

OpenAI gives figures for its own pair. The smaller gpt-oss model has 21 billion parameters and runs within 16 GB of memory. The larger one has 117 billion and wants a single 80 GB graphics card.

Those two figures are smaller than the earlier rule would give you. Two bytes for each of 21 billion numbers comes to far more than 16 GB. OpenAI names the reason: it ships these models with the numbers already squeezed into a smaller form. The name for that squeeze is quantization, and lesson eight is where you meet it properly.

And you need somewhere to keep the file, plus space for the next one you want to try. People rarely stop at one.

Backed by gpt-oss-20b model card.

Not every parameter is working

One design breaks the simple story, and you will meet it by name on download pages.

Look again at those two OpenAI models. gpt-oss-20b has 21 billion parameters, but OpenAI says only 3.6 billion of them are active at a time. gpt-oss-120b has 117 billion, with 5.1 billion active.

Sit with the second pair for a moment. Nearly six times the parameters, and fewer than one and a half times as many doing work on any one token.

What that buys you is something closer to a big model's knowledge at something closer to a small model's speed.

What it costs you is the room. All 117 billion still have to be somewhere the machine can reach, which is why it wants an 80 GB card.

So the honest headline for memory is the total count. The honest headline for speed is the active count. When you see two numbers like that, this is what they are telling you.

Backed by gpt-oss-20b model card.

Bigger runs slower

A speed claim means nothing unless it names the hardware, so here is one that does.

The llama.cpp project keeps a table of its own measurements on Apple machines. They ran a 7 billion parameter Llama 2 model, in the most compact of the three forms they tested. It wrote about 14 tokens a second on an M1, and about 83 on the fastest M4 Max in their table.

Now hold the machine still and change only the file. On one M2 Max, the same model gave 24.65 tokens a second in its largest form, 41.83 in the middle one and 65.95 in the smallest.

More bytes to read, less text per second. The project plots this against memory bandwidth, which is how fast a machine can read from its own memory.

One honest caveat: those figures all come from a single 2023 build, picked so the machines can be compared fairly. The project says later versions are faster.

Backed by Performance of llama.cpp on Apple Silicon M-series.

How long you wait is a separate question

Two models of the same size can feel completely different to sit through, and size has nothing to do with why.

Some models write out their reasoning before they answer. Qwen3-8B is one. Its card calls this thinking mode and says it is on unless you turn it off.

How much extra writing is that? Qwen recommends allowing an output length of 32,768 tokens for most questions, and 38,912 for hard maths and programming problems. That is a great deal of text before the part you asked for.

The card gives you a switch. Setting enable_thinking to false turns it off, and Qwen says that is useful where speed matters more. You can also type /no_think in a message to do it for one turn.

So the wait has two halves: how fast the model writes, and how much it decides to write. Only the first one is about size. Track 5 pulls the two apart properly.

Backed by Qwen3-8B model card.

The trade is the point

Put these together and you have the shape of nearly every choice ahead of you.

• Bigger tends to be more capable, as long as you stay inside one family.
• Bigger needs more memory, and memory runs out before anything else does.
• Bigger writes more slowly on the same machine, unless the design keeps most parameters idle.
• The file is usually larger than the name suggests, so read the Files tab.
• None of these can be bought without paying in the others.

Backed by Scaling Laws for Neural Language Models, gpt-oss-20b model card, Performance of llama.cpp on Apple Silicon M-series, Qwen3-8B repository files.