Gemma 4 26B A4B: A 3.8B-Active MoE Under Apache 2.0

The name tells you most of what you need, once you know how to read it. "26B" is the size you have to fit in memory. "A4B" is the size you pay compute for on every token. The distance between those two numbers is the whole design, and it is why this model behaves so differently from the dense Gemma releases before it.

Google released Gemma 4 on 2 April 2026 in four sizes: E2B and E4B for phones and edge devices, a 31B dense model, and this one, a mixture-of-experts model that Google ranked sixth among open models on Arena AI's text leaderboard at launch, with the 31B third.

What the numbers actually are

The Hugging Face model card gives 25.2B total parameters and 3.8B active per token — the marketing name rounds both. The feed-forward layers hold 128 experts, of which 8 are routed per token plus one shared expert that every token passes through. There are 30 layers, local attention uses a 1,024-token sliding window, and the context is 256K tokens.

Google's announcement says all Gemma 4 models process images and video at variable resolution, including OCR and chart reading; native audio input is reserved for the E2B and E4B. The vision encoder on this model is about 550M parameters. Google also lists native function calling, structured JSON output and native system instructions as features of the family.

Memory like a 25B, compute like a 4B

This is the property to plan around. Every expert has to be resident in memory, because any token might route to any of them. So the memory footprint is that of a 25B model. But each token only runs through 3.8B parameters of computation, so throughput and latency look much more like a small model's.

Google says the unquantised bfloat16 weights of both the 26B and 31B fit on a single 80 GB H100, and that quantised builds run on consumer GPUs. At the same quantisation the 26B needs somewhat less memory than the 31B, but not dramatically less. The real difference is speed: the MoE does a fraction of the arithmetic per token, so on the same card it should generate tokens considerably faster. Measure that on your own hardware rather than assuming a ratio.

The practical consequence: if memory is your constraint, the MoE does not save you anything over the dense 31B. If throughput or cost per token is your constraint, it saves a lot. Active vs total parameters covers this trade across the current field, and mixture of experts explained covers why routing works at all.

The gap to the 31B dense, row by row

Google's model card puts the two side by side, with Gemma 3 27B as the baseline:

• MMLU Pro — 82.6% for the 26B A4B, 85.2% for the 31B, 67.6% for Gemma 3 27B
• AIME 2026, no tools — 88.3%, 89.2%, 20.8%
• LiveCodeBench v6 — 77.1%, 80.0%, 29.1%
• GPQA Diamond — 82.3%, 84.3%, 42.4%
• Tau2, average over three domains — 68.2%, 76.9%, 16.2%
• MMMU Pro — 73.8%, 76.9%, 49.7%

On knowledge, maths and coding the MoE is within one to three points of the dense model. The exception is Tau2, an agentic benchmark built on multi-turn tool use with simulated users, where the gap widens to nearly nine points. If your workload is an agent loop, that is the row to weigh; for single-turn generation the cheaper model gives up very little.

The jump over Gemma 3 27B is large on every row, and enormous on the agentic one. Note that the Gemma 3 figures are without thinking, so part of the gap reflects Gemma 4's reasoning mode rather than the base model alone. For the dense sibling, see the Gemma 4 31B guide.

Thinking is opt-in, through the system prompt

Gemma 4 has a reasoning mode, and it is switched on by a control token at the start of the system prompt rather than by an API parameter. With Hugging Face Transformers you pass a flag to the chat template instead:

messages = [
    {"role": "system", "content": "You are a careful code reviewer."},
    {"role": "user", "content": "Find the bug in this function: ..."},
]
inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    enable_thinking=True,
)

Without the flag, the template omits the <|think|> token and the model answers directly, though the model card notes it still emits an empty thought block, so your parser should expect one. When you call it through a hosted gateway, check how that provider exposes the switch; it may map an OpenAI-style reasoning parameter onto the token, or it may not expose it at all.

Thinking costs output tokens. Leave it off for extraction and classification, and turn it on for maths, multi-step coding and planning, where the benchmark gains above come from.

The licence change matters more than it looks

Gemma 1, 2 and 3 shipped under Google's own Gemma Terms of Use, a custom licence with a prohibited-use policy attached. Gemma 4 ships under Apache 2.0. For anyone building a product on the weights — fine-tuning, redistributing, or serving inference to customers — that removes a custom document from legal review and replaces it with one most companies have already approved.

It also changes the comparison set. Apache 2.0 puts Gemma 4 alongside Qwen and other permissively licensed families rather than in the custom-licence group. Open-weight model licences compared covers what each licence actually permits.

Hosted pricing and the free variant

OpenRouter listed the model at $0.0675 per million input tokens and $0.225 per million output at the time of writing, with cached reads at $0.0375. That is cheaper than Gemma 3 27B on the same catalogue.

There is also a google/gemma-4-26b-a4b-it:free variant: the same model on a zero-cost, rate-limited endpoint, listed with a lower output cap than the paid route. It is fine for trying the model and for personal tools; it is not something to put production traffic behind, because limits can change without notice and throughput is shared.

How to evaluate it

1. Decide whether you are constrained by memory or by throughput. If memory, compare it with the dense 31B at the same quantisation; if throughput, compare tokens per second on your hardware.
2. Run your real prompts with thinking on and off, and record output tokens as well as accuracy.
3. If you run agents, build a small multi-turn tool-use test. The Tau2 gap suggests that is where the 31B earns its extra compute.
4. Check image and video handling on your own inputs before relying on the vision claims.

For most single-turn and retrieval workloads, expect the 26B A4B to be the better-value Gemma 4. For long tool-calling loops, test both before deciding.