MiniCPM-V 4.7 1B vs UI-Venus 2 9B: One Fits in a Pocket, the Other Needs a Rack

The comparison between MiniCPM-V 4.7 1B and UI-Venus 2 9B is not close, and that is the useful thing about it. MiniCPM-V 4.7 1B is a 1.55-billion-parameter general vision-language model from OpenBMB, uploaded October 6, 2026, dated October 12 in the vendor's release notes, Apache 2.0, and small enough to run inside a phone app. UI-Venus 2 9B is a 9.41-billion-parameter GUI agent from inclusionAI, released August 26, 2026, trained specifically to look at a screen and decide where to tap, type or swipe, and it expects a GPU with a vLLM server in front of it. The documented AI failures and agent incidents behind releases like this one are collected in the OrcaRouter AI Incident Archive where each entry carries its own sources, severity, confidence grade and disputed flag.

Putting them in the same sentence invites the wrong question — which one is better — when the right one is what each is for. A general vision model that fits in 1.8 GB of quantised memory and a screen-agent that scores 73.0 on ScreenSpot-Pro are not substitutes. They are two different layers of a mobile automation stack, and the interesting part is where the boundary between those layers actually sits.

Two jobs that look similar from a distance

Both models can accept a screenshot and return text about it. That is where the resemblance ends.

MiniCPM-V 4.7 1B reads an image and describes, transcribes, extracts or answers. Ask it what a receipt total is, what a form field contains, whether a chart trends upward, or what a page of a PDF says, and it will produce an answer. It has slicing controls for high-resolution images, a switchable 4×/16× visual token compression ratio, and frame-sampling parameters for video. Its documentation covers single-image chat, multi-image chat, video, OCR, PDF parsing and visual grounding — a document-and-screen reading workload.

UI-Venus 2 9B reads a screen and emits an action. Its card describes a closed loop: observe the interface, reason about task state, execute an action, incorporate the environment's feedback into the next decision. The outputs are points and action sequences, not prose. Around it, inclusionAI ships reference prompts, action parsers and runnable examples for mobile, computer, browser, grounding and CAPTCHA tasks. The model is a policy, and the harness around it is half the product.

That distinction decides the architecture before any benchmark is consulted. A phone app that needs to read a receipt uses the first. A system that needs to complete a task inside an app — tap through a checkout, fill a form, solve a slider CAPTCHA — uses the second, and cannot substitute the first no matter how good its OCR is.

The licence is the first filter, not the benchmark

UI-Venus 2 9B's card contains a release-status section that most coverage has skipped over. Under "Model weights" it says the weights are included; under "License" it says the model-weight licence is pending final confirmation and will be added before public release, and that the Apache-2.0 declaration was deliberately not carried over because the upstream materials contain conflicting licence statements.

Read that twice. The weights are downloadable, the benchmarks are published, the technical report is on arXiv, and the licence is unresolved. For a research team that is fine. For a company planning to ship a screen agent inside a commercial product, it means the legal review cannot close. The model may end up Apache 2.0, or it may not, and there is no way to know from the artefacts available today.

MiniCPM-V 4.7 1B ships under Apache 2.0 with no such ambiguity. That single line eliminates one of the two models for a large class of commercial work — not because it is worse, but because a pending licence is a schedule risk nobody budgets for.

The hardware arithmetic, before any score

• Weights — 1.55B dense, about 3.1 GB BF16, 0.67 GB at Q4_K_M plus a 0.90–1.11 GB vision projector vs 9.41B, roughly 18.8 GB BF16 across four safetensors shards • Where it runs — iOS, Android and HarmonyOS apps; day-0 chip support from Rockchip, Houmo, Intel, AMD and Arm vs a GPU serving path, documented with vLLM at --max-model-len 262144 and --reasoning-parser q​wen3 • Context — 262,144 tokens on paper, with a KV cache that costs more than the weights at full length vs 262,144 tokens, inherited from the Qwen3.5-9B base • Vision stack — a 27-layer, 1152-hidden encoder on 980-pixel tiles with intra-encoder token compression vs the Qwen3.5-9B vision tower, carried over from the base model • Licence — Apache 2.0 vs pending confirmation, with the Apache-2.0 declaration explicitly withheld • Evaluation style — five prose figures plus chart-only comparisons vs a full numeric appendix across mobile, computer, web, grounding, CAPTCHA and safety • Independent evaluation — none for either model as of this writing vs none, though the technical report at arXiv 2609.00028 is a substantial third-party-checkable artefact

The gap here is roughly an order of magnitude in memory: 1.8 GB quantised against 18.8 GB in BF16, or about 5 GB at 4-bit if you quantise. That is the difference between an app and a service. It is also why the two models are usually discussed in different articles — one is an edge deployment question and the other is an inference-cost question.

Where the 9B earns its size

UI-Venus 2 9B's numbers, all vendor-reported from its card and technical report, put it near the top of the sub-10B GUI class. On ScreenSpot-Pro, which measures element localisation on high-resolution professional software, it reports 73.0. On VenusBench-GD, 77.1. On OSWorld-G-R, 78.5. On AndroidWorld, 80.2. On WebVoyager's refreshed 595-task split, 90.8. On OSWorld-Verified, 70.8. On its own VenusBench-CAPTCHA, 78.1 pass@1 across eight interaction types.

Those are not numbers a 1B generalist produces, and they are not meant to be. What makes them credible rather than decorative is the training description: a mobile pool of 170-plus multilingual apps, a web pool of 4,000-plus domains across 19 categories, three training stages (multimodal mid-training, offline RL across five task families, multi-teacher on-policy distillation), and a verification scheme built on task-relevant visual keypoints with multi-model voting rather than a single judge looking at the final screen. The card also reports safety results — 11.3% attack success rate on OSHarm and 48.8% on OSBlind, against 25.3% and 79.4% for the Qwen3.5-9B base — and frames them as a comparison against that base rather than as an absolute robustness claim, which is the correct framing.

None of this transfers to a 1B model. GUI agency is trained, not emergent from general vision competence, and no amount of OCR accuracy substitutes for a policy that knows what a "next" button does.

Where the 1B wins anyway

Three places, and they are not consolation prizes.

Latency and availability. A local 1B has no network round trip, no queue, no provider outage, and no per-request cost. For a scanning feature used fifty times a day, that is the entire product experience. A 9B behind a vLLM server is fast — but it is fast in the way any hosted model is fast, and it stops being fast when the connection does.

Privacy by construction. A receipt, an ID document, a medical form or a screenshot of a private conversation can stay on the device. That is not a marketing line; it is the difference between a feature you can ship in a regulated industry and one you cannot. UI-Venus 2 9B's own safety evaluation is about the model misbehaving on the server side. The 1B's privacy property is that the image never leaves the phone.

Cost at the margin. Reading a screenshot with a hosted 9B costs money per request, every request, forever. Reading it with a local 1B costs the battery. At low volume the hosted option is cheaper; at high volume — a scanner in a field app, an accessibility tool, a batch of ten thousand receipts — the local model is the only one whose marginal cost approaches zero.

The stack most teams actually end up building

Not a choice between these two. A layering of them.

The on-device 1B handles perception: read the screen, extract the text, find the field, describe what is there. Most of the time that is enough, and the request never leaves the phone. When the task requires an action — tap this, swipe there, complete this flow — the job goes to an agent, and an agent needs a bigger model with an action vocabulary.

That handoff is where a routing layer earns its keep, and it is worth being precise about what it does and does not do. OrcaRouter exposes 200-plus hosted models through one OpenAI-compatible endpoint at 0% markup, passing each provider's list price through unchanged, with automatic failover and a routing DSL that can hold a primary and a fallback in one call. The pattern this enables is unglamorous and useful: the phone tries its local 1B, the app escalates the hard cases to a hosted vision model over the same key it uses for everything else, and a provider having a bad afternoon becomes a failover event rather than an outage. Neither MiniCPM-V 4.7 1B nor UI-Venus 2 9B is in that catalogue — both are checkpoints you run yourself — so the router is the layer around the stack, not a way to call either model.

Two failure modes worth planning for

The first is a 1B generalist used as an agent. It will read a screen correctly and then have no idea what to do with it. If your product needs to complete a flow rather than describe one, the 1B is the wrong tool and no prompt fixes it.

The second is a 9B agent shipped on a model card's licence status. UI-Venus 2 9B's card says the licence is pending and that the Apache-2.0 declaration was intentionally withheld. Until that resolves, the model is a research artefact for commercial purposes, however good the ScreenSpot-Pro number is. Teams that plan around "it will probably be Apache 2.0" are taking a schedule risk they have not priced.

What the choice actually comes down to

If the question is "can I read this screenshot on a phone, offline, for free, with a licence I can ship" — MiniCPM-V 4.7 1B answers yes, at about 1.8 GB quantised, under Apache 2.0, and the only thing you have to verify is your own device's memory headroom.

If the question is "can this model operate the interface rather than describe it" — UI-Venus 2 9B is the one with the training, the benchmarks and the harness, and it needs a GPU and a licence decision before it needs anything else.

If the question is "both, in one product" — then you are building a two-tier system, the 1B doing perception on the device and the agent doing action on a server, and the engineering work is the handoff between them rather than the choice between them.

The comparison looks lopsided because it is. A 1B generalist and a 9B GUI specialist are not in the same weight class, the same deployment class, or the same licensing position. The mistake would be reading that as "one is better." They are answering different questions, and the fastest way to pick is to write down which question you are actually asking.