How Gemma 4 made small AI models powerful enough to see

There is a race happening in AI, and for a long time everyone agreed on how it worked. Bigger models win. More parameters, more power, more capability. It was the rule the whole industry built itself around.

Then Google DeepMind quietly released a model with 4.5 billion parameters, gave it away for free, and it could see.

Not just process text. Actually look at an image, understand what was in it, reason about it, and respond. All from a model small enough to run on a phone.

That model is Gemma 4, part of a family of open-weight AI systems from Google DeepMind that range from something that fits in your pocket to something that competes with the best closed AI in the world. The family has been downloaded millions of times. It is licensed under the Apache 2.0 license, which means you can download, modify, and build a business on top of it. Google gave you the weights, the architecture details, and a published technical report explaining how it all works.

They gave you everything. And the most interesting thing in that package is not the benchmark scores. It is how they taught a tiny model to see.

What Gemma 4 Actually Is

Gemma is Google DeepMind’s family of open-weight models, the downloadable counterpart to Gemini. While Gemini runs on Google’s infrastructure and reaches you through an API, Gemma is yours to keep. You download the weights, run it on your own hardware, and no request ever leaves your machine.

Gemma 4 comes in five sizes, each designed for a different kind of hardware. The two smallest, called E2B and E4B, run on phones and edge devices. They have 2.3 B and 4.5B effective parameters, respectively—the 12B and 26B handle mid-range hardware. The 31B dense model sits at the top, running on a high-end GPU or a well-equipped workstation.

All of them are multimodal. Every single model in the family can look at an image and understand it. Most of them can also hear audio.

Now compare that to DeepSeek V4 Pro, a model with 1.6 trillion total parameters, one of the largest AI systems publicly available. It cannot see a picture. It has no vision support at all. You send it an image; it cannot process it.

Google built models that are roughly 99 per cent smaller in parameter count, and they have eyes. That gap tells you something important about where the interesting work in AI is actually happening.

The Secret Is How It Sees

This is the part worth understanding, because it is genuinely clever.

Most AI models that can process images use what is called a vision encoder: a separate system that looks at an image, processes it into a format the language model can understand, and then hands that processed version over. It is a two-stage pipeline. The image goes in, the encoder does its work, and the language model gets the result.

Gemma 4 does something different for its smaller models, and something even more interesting for its 12B variant.

For the edge and smaller models, Google built lightweight vision encoders using a technique that breaks an image into small patches, each 16 by 16 pixels. The model does not look at the whole image at once. It looks at one small piece at a time, processes each patch, and then pools them into a grid that represents the full picture. Each patch gets a positional embedding so the model knows where in the image it came from. The result is that the model understands spatial relationships: it knows what is in the top-left corner versus the bottom-right, and it can reason about how those pieces relate to each other.

For the 12B model, Google went further and removed the encoder entirely. Instead of a separate vision processing system, the 12B takes raw image patches and projects them directly into the same mathematical space the language model already thinks in. There is no handoff between systems. The image arrives, is sliced into patches, and those patches flow straight into the model’s core, where they are processed alongside text in a single unified pass.

Think of it like translation. Older systems would translate an image into a language the AI speaks, then hand it to the AI to read. Gemma 4’s 12B model does not need the translation step. It reads the image directly.

The result is lower latency, a simpler architecture, and a model that can be fine-tuned as a whole rather than requiring separate tuning passes for each modality.

Small Model, Large Performance

Here is where the numbers start to matter.

The smallest Gemma 4 model, the E2B with 2.3 billion effective parameters, performs at roughly the level of Gemma 3 27B, its much larger predecessor. That is ten times fewer parameters delivering the same capability. The 31B dense model, the largest in the family, sits third on the Arena AI open-source leaderboard with an Elo score of 1,451. On AIME 2026, a competitive mathematics benchmark, it scored 89.2 per cent. On coding benchmarks, it hits 80 per cent. On MMLU-Pro, a broad knowledge evaluation, it scores 85.2 per cent.

These are not small-model scores with a footnote about the size. These are competitive results against models that require significantly more hardware to run.

The second image you saw, the one showing Gemma 4 E4B improvements on agentic benchmarks, tells a more specific story. On Tau2 Airline tasks, the E4B improved by 8 percentage points over its predecessor, and on Tau2 Telecom it improved by 6.1 points. These are the kinds of tasks where an AI has to use tools, follow multi-step instructions, and complete workflows without a human checking every step. Agentic capability in a model small enough to run on a laptop is not a minor detail. It is the reason developers are paying attention.

The 31B supports a context window of 256,000 tokens. The smaller models support 128,000. All of them support over 140 languages, native function calling, structured output, and a thinking mode that lets the model reason through a problem step by step before responding.

What Google Actually Gave You

The technical report accompanying Gemma 4 is not a press release. It is a detailed explanation of architectural choices: why they designed the vision system the way they did, how the encoder-free approach works mathematically, what tradeoffs they made at each model size, and where the performance gains came from.

This is unusual. Most frontier AI labs publish benchmark results and keep the engineering decisions private. Google published the decisions. The technical report, the model card, and the architecture documentation are all public. Anyone who wants to understand why Gemma 4 sees the way it does can read the actual reasoning.

The license matters too. Apache 2.0 means there are no restrictions on commercial use, no royalty requirements, and no rules about what you can build. You can run Gemma 4 in a product, fine-tune it on your own data, modify the architecture, and ship it to customers. Google’s permission is not required.

That combination- open weights, published architecture, permissive license, and genuine multimodal capability at small model sizes- is what makes Gemma 4 different from most of what gets announced in AI. It is not a product you access. It is a tool you own.

Why This Keeps Mattering

Every few weeks now, another model arrives, challenging the assumption that capability requires scale. Qwen 3.8 27B beat models many times its size through better training. DeepSeek V4 Pro competed with frontier closed systems at a fraction of the price. And now, Gemma 4 gives a 4.5-billion-parameter model the ability to see, reason, and act, while a 1.6-trillion-parameter competitor cannot process a single image.

The pattern is the same in each case. The interesting work is not happening at the frontier of scale. It is happening in architecture design, training methodology, and the specific choices about how a model processes information. Bigger is not always better. Sometimes smaller, built more carefully, is more capable in the ways that actually matter for the work people need to do.

Gemma 4’s smallest model fits on a phone. It can look at a picture, read a document, hear audio, follow instructions in over 140 languages, and reason through a multi-step problem before responding—no cloud required. No subscription. No company in the middle.

That is not a consolation prize for people who cannot afford the big models. That is a different and arguably more useful thing entirely.