A 3B Model Beat Gemini 4 on Phone Screens—And It Runs in 2GB of RAM

The claim on the box

Nexa AI, a startup that has spent two years shrinking models for phones and laptops, released what it calls Nexa VLM 3B this week. The pitch: a vision-language model that can look at a screenshot, a receipt, or a settings menu and answer questions about it, all while running on-device in roughly 2GB of quantized memory.

The headline number Nexa is pushing is a comparison to Gemini 4 on screen-understanding tasks. According to the company’s blog post, the 3B model scores within a few points of Google’s flagship on a benchmark called ScreenQA. That is a bold claim for a model small enough to fit in the RAM budget of a mid-range Android phone.

Here is the part that matters for builders: Nexa is not claiming the 3B model is smarter than Gemini 4. It is claiming that for a narrow, high-value task — reading what is on a screen — the gap is small enough that the latency and privacy benefits of running locally win.

What ScreenQA actually measures

ScreenQA is not a general intelligence test. It is a visual question-answering benchmark built from real mobile app screenshots. The questions are things like “what is the price shown?” or “which button is disabled?” The model gets an image of a UI and a question, and must produce a short answer.

That narrowness is the point. A model that can reliably parse a screen can power an assistant that fills forms, summarizes notifications, or walks a user through a checkout flow without sending a single pixel to a server. It is also the kind of task where a 3B model can plausibly compete, because the visual distribution is constrained: text, buttons, icons, and layout, not the open world of photographs.

Nexa’s blog does not publish the exact ScreenQA scores in the post, only the claim of parity within a few points. The model card on Hugging Face lists the full evaluation table. That is where a careful builder should look before believing the headline.

The 2GB number is doing a lot of work

Memory claims in on-device AI are always conditional. Nexa says the model runs in about 2GB when quantized to 4-bit. That is the weight footprint, not the total runtime memory. Once you add the KV cache, the image encoder, and the app overhead, the real number on a phone will be higher.

The comparison that matters is not against a data-center GPU. It is against the alternative: a 7B or 8B vision model that needs 4-6GB of quantized weights and will not fit comfortably alongside a mobile OS on a 6GB phone. Nexa is targeting the tier of device where every hundred megabytes counts.

Nexa’s own documentation recommends 4-bit quantization for mobile and 8-bit for laptops. The company also ships an ONNX export, which means the model can run through standard runtimes rather than a proprietary stack. That is a practical detail that matters more than any benchmark point.

Where small vision models break

Every builder who has shipped an on-device VLM knows the failure modes. Small models are good at reading clean text and bad at reasoning about ambiguous layouts. They hallucinate numbers when the font is small. They struggle with charts, dense tables, and anything that requires counting more than a handful of items.

Nexa’s model is no exception. The company’s own examples focus on receipts, forms, and settings screens — structured, high-contrast, text-heavy images. That is the sweet spot. A builder who tries to use it to describe a photograph or read a handwritten note will see the gap to Gemini 4 widen quickly.

The honest framing is that this is a tool for a specific job, not a general-purpose assistant. If your app needs to extract a total from a receipt on a device with no reliable network, a 3B model that fits in 2GB is a real option. If your app needs to understand a whiteboard sketch, keep the cloud model.

The latency math builders should run

Nexa claims sub-second time-to-first-token on a modern phone for image inputs. That number depends on the device, the image resolution, and the quantization. On a flagship with a strong NPU, it is plausible. On a three-year-old mid-range phone, expect two to three seconds before the first token appears.

That still beats a round trip to a cloud API in many cases, especially on poor mobile networks. The privacy argument is stronger: no image leaves the device, which matters for banking apps, health apps, and anything handling documents a user would rather not upload.

The cost argument is the weakest of the three. Cloud inference for a single screenshot is cheap. The real savings show up at scale, when an app is processing millions of screens a day and the per-call cost adds up.

What Nexa has not shown

Nexa’s announcement does not include a head-to-head latency comparison against Gemini 4 running through an API on the same device. It does not break down ScreenQA by question type, so we cannot see whether the 3B model is close on simple extraction and far behind on multi-step reasoning. And it does not publish the failure cases.

Those gaps are normal for a launch post. They are also the reason a builder should download the weights and run their own eval set before committing. The model is small enough that a laptop can run it, and the ONNX export means you can test it in a standard pipeline rather than a vendor sandbox.

The broader trend is real: small vision models are getting good enough for narrow tasks, and the gap to frontier models is closing fastest where the task is constrained. Nexa’s 3B model is a data point in that trend, not a proof of it.

How the 3B model fits in 2GB

To get a vision-language model into 2GB, Nexa relies on aggressive quantization. The 4-bit weights are the bulk of that figure, but the architecture also matters: the image encoder is likely a compact ViT, and the language backbone is a small transformer. The KV cache grows with context length, so a longer conversation or a high-resolution image will push memory use higher. Nexa’s documentation notes that 4-bit is recommended for mobile, but it does not specify the exact context window or image resolution that keeps the total under 2GB. Builders should measure peak memory on their target device, not assume the box number.

The benchmark caveat: what ‘within a few points’ hides

A few points on ScreenQA could mean the difference between usable and frustrating. If the 3B model scores 85% and Gemini 4 scores 90%, that is a 5-point gap — but on a task where 90% is the threshold for a smooth user experience, the small model may fail one in seven queries instead of one in ten. For a form-filling assistant, that error rate matters. Nexa’s blog does not give the absolute scores, so builders cannot judge whether the gap is in the easy questions or the hard ones. The model card’s evaluation table may break down by question type, but until then, treat the headline as a directional signal, not a guarantee.

What this means for your app

If you are building an app that needs to read screens — receipts, forms, settings — and you cannot rely on a network, Nexa VLM 3B is worth testing. The 2GB footprint fits on mid-range phones, the ONNX export means you can integrate it with standard tooling, and the privacy benefit is real. But do not expect it to replace a cloud model for open-ended image understanding. Run your own eval on a sample of your users’ screenshots, measure latency on your minimum supported device, and check the license before shipping. The model is a tool for a narrow job; used well, it can cut latency and keep data on-device. Used as a general assistant, it will disappoint.

Frequently asked questions

Can Nexa VLM 3B really match Gemini 4? On ScreenQA, a narrow screenshot question-answering benchmark, Nexa claims it is within a few points. On open-ended image description, the gap is much larger.

What hardware do I need to run it? Nexa recommends 4-bit quantization for phones and 8-bit for laptops. The weights fit in roughly 2GB at 4-bit, but total runtime memory will be higher once the image encoder and KV cache are loaded.

Is it free to use commercially? Nexa publishes the model on Hugging Face. Check the model card for the exact license before shipping it in a product.