Yuval Avidani
Author
Turns out one of the most talked-about numbers in the open model world, "Gemma 4 31 billion parameters," got stuck with a label that doesn't actually belong to it: everyone calls it the fast one, when it's actually Google's heaviest and highest-quality model.
Let's break this down, because this is exactly the kind of confusion that makes us pick the wrong model for the job.
What actually happened here
On April 2, 2026, Google released the Gemma 4 family, describing it as its most capable open models to date. Gemma 4 came out under the Apache 2.0 license, meaning real open-source that you can even use commercially, no asterisks. Quick note on one term: "open model" means a model Google lets us download to our own machine, run locally, and even modify — as opposed to a closed model that only runs on their servers while we just send it requests. Why this matters to us: it means we can run this on our own machine, without paying per token and without sending our data to anyone's cloud.
The family comes in several sizes: two small models called E2B and E4B (short for Effective 2B and Effective 4B, meaning "effectively the size of 2 and 4 billion parameters"), a 26 billion parameter model in MoE architecture, and a dense model called 31B Dense.
Where everyone gets confused
Now for the part that causes headaches. The name "31B" accidentally got glued to a trait belonging to a different model: speed.
Turns out the 31 billion parameter model is not the fast one. Google explicitly says the 31B Dense is the model that maximizes raw quality, not speed. "Parameters" are, broadly, the internal numbers the model learns, and generally the more of them there are, the smarter the model is — but also heavier and more memory-hungry. So 31B is the powerhouse, the one you want when you're after the best possible answer and don't mind waiting a bit longer.
The real fast model is actually the 26B, and here's a term worth understanding: MoE, short for Mixture of Experts. Instead of waking up the entire brain for every single word, the model holds a huge number of small "experts" and only lights up a few of them per token. The 26B activates only about 3.8 billion parameters per token — eight experts out of 128, plus one shared expert — so it runs at the speed of a tiny model but with the smarts of a large one.
Let's picture it this way: a dense model like 31B is like calling in the entire hospital staff for every patient who walks through the door. Works, but expensive and slow. An MoE model like the 26B is like a smart triage that sends you straight to the right doctor. Same quality, way less load, way faster. That's why the 26B pumps out a lot of tokens per second, and that's exactly what people meant when they said "the fast Gemma 4."
What this actually gives us
Beyond the sizes, there are a few more things here worth gold.
First, the context window — meaning how much text the model can hold in its head at once. For the small ones, E2B and E4B, that's 128 thousand tokens. For the 26B and 31B it climbs up to 256 thousand tokens, enough to feed in an entire book or a serious codebase. Why this matters to us: less need to chop documents into pieces — the model just sees the whole picture.
Second, it's multimodal. Meaning the models accept both images and video as input, and the E2B and E4B also have built-in audio input. There's also a later variant that shows up on the list, Gemma 4 12B "Unified," a multimodal model without a separate encoder — but I'll flag its exact date as reported, not officially confirmed here.
And third, running it locally is straightforward. The 31B is available on Hugging Face both as a base model and as an instruction-tuned one, there are GGUF format quants, and there's a ready-made Ollama tag called gemma4:31b. "Quantization" is compressing the model into smaller numbers so it fits into the memory of our home computer, no server-farm-grade graphics card required.
On the shiny numbers, carefully
There are impressive numbers floating around online: that the 31B hits around 1452 on LMArena compared to Gemma 3 27B's roughly 1365, that Cerebras runs the 31B at about 1,800 tokens per second, and that cloud providers report output speeds like around 195.8 from SambaNova and around 70.6 from Together AI.
Bottom line on these numbers: they come from secondary sources and press reports, not from my own independent measurement. The sizes, the license, and the date are confirmed directly by Google and Hugging Face, but I'm presenting the exact benchmarks as reported, not as absolute truth. That's how I think marketing numbers should always be consumed.
Bottom line
To me, the real story here isn't "who's fastest," but how easy it is to slap the wrong label on a model and then make the wrong choice. If we want maximum quality and have memory to spare, 31B Dense is the pick. If we want speed and a lot of tokens per second, 26B MoE is the one. Both are real, both are fully open, both run locally.
The limitation I'm placing on myself here: I didn't test the benchmarks myself, and I'm flagging the 12B Unified as reported only. And of course, this isn't investment advice in any direction — it's a technical read.
So before we jump on the biggest number on the list, a small question: when's the last time we picked a model based on what we actually need, rather than what the internet decided to call it?