Glimpse vs Gemma 4 12B: A Rewind Mechanism Against a Download

These two are compared to each other mostly because both are described as vision models, and that description is doing almost none of the work. Glimpse, released by Elorian on 16 October 2026, is a hosted research preview whose defining behaviour is that it can go back and look again — re-scanning part of a clip at a denser frame rate, zooming into a region, or tracking one feature across time — and it is reachable only through the vendor's API and chat interface. G​emma 4 12B is a dense, 11.95-billion-parameter open-weights checkpoint from G​oogle DeepMind, shipped 3 June 2026 under Apache 2.0, that you download and run on your own hardware and that closes the same question the opposite way: it is a fixed artefact with a fixed frame-sampling schedule, and no amount of looking at it will make it rewind.

So the honest framing is not "which is better at vision." It is that one of these is a capability you rent and the other is a file you own, and the choice between them is decided by facts that have nothing to do with benchmark rows.

The distinction that actually decides it

Start with what each one is physically. G​emma 4 12B is a set of weights. The instruction-tuned checkpoint on Hugging Face is a single 23.92 GB safetensors file at bfloat16; G​oogle's own quantisation-aware-training builds come in around 6.98 GB for the weights plus a 0.18 GB multimodal projection file, and a community Q4_K_M build lands near 7.1 GB. You can hold it, fine-tune it, quantise it further, ship it inside a product, and run it with no network and no meter. That is the whole proposition.

Glimpse is the opposite shape of object. There are no weights. There is no parameter count, no downloadable artefact, and no published architecture beyond the statement that it was post-trained on an "open weights base model" that Elorian does not name. What exists is an API, a chat interface at platform.elorian.ai with a free sign-up, and a published behaviour: the model's visual scratch space, in which it revisits and refines internal visual representations as thinking unfolds.

That asymmetry is the first thing to price in, and it cuts both ways. A downloadable checkpoint cannot be deprecated out from under you, cannot change behaviour behind a version string, and cannot fail at 3am because someone else's us-east-1 is unhappy. A hosted preview with a rewind mechanism cannot be run on an air-gapped machine, and — the point that matters most for a G​emma 4 12B comparison — cannot be made to fit in 16 GB of memory, because there is nothing to fit.

What the rewind buys, in the vendor's own numbers

Elorian's worked examples are the most concrete thing published about Glimpse, and they are worth reading as descriptions rather than as scores. In one trace the model takes a first pass at roughly 8 frames per second, forms a tentative reading, then goes back and re-scans a 0.9-second window at around 14 fps to decide whether what it is seeing is a pan or a cut. In another, it follows a single window edge from about 2.2 seconds into a clip until the motion comes to a near stop at 5.13 seconds.

G​emma 4 12B has no equivalent. It processes video as frame sequences on a schedule you choose, and once the frames are selected, whatever fell between them is gone. That is not a defect — it is what an open-weights checkpoint with a published inference path is supposed to do — but it is the exact class of question the rewind exists to answer.

Where G​emma 4 12B pulls ahead is on everything you do with a model. On G​oogle's own card, which covers the whole family and is vendor-reported rather than independently reproduced, the 12B scores 77.2% on MMLU Pro, 78.8% on GPQA Diamond, 77.5% on AIME 2026 without tools, 72.0% on LiveCodeBench v6, a Codeforces ELO of 1659, 69.1% on MMMU Pro and 43.4% on MRCR v2 at 128K with eight needles. Glimpse publishes nothing in that family at all — no reasoning benchmark, no coding benchmark, no knowledge benchmark. The comparison is not close because the comparison was never run.

The scorecards, and which blanks are deliberate

The two published evidence sets do not intersect. Glimpse's table is against GPT-6 Astra and it is vendor-reported with no independent reproduction; the same is true of G​oogle's table. Reading them side by side is still useful, because it shows what each company chose to be measured on.

• WGO Bench (manipulation events) — Glimpse 42.70 vs Astra 39.42. G​emma 4 12B: not reported.

• CharXiv-R — Glimpse 92.90 vs 92.10. G​emma 4 12B: not reported.

• UGC-VideoCap — Glimpse 82.66 vs 80.32. G​emma 4 12B: not reported.

• FSC-147 — Glimpse 83.36 vs 82.02. G​emma 4 12B: not reported.

• Video-MME v2 — Glimpse 56.68 vs Astra 64.06 and GPT-6.1 Sol 65.27. G​emma 4 12B: not reported.

• Humanity's Sixth Sense — Glimpse 46.36 vs Astra 53.6. G​emma 4 12B: not reported.

• MMLU Pro — G​emma 4 12B 77.2%. Glimpse: not reported.

• LiveCodeBench v6 — G​emma 4 12B 72.0%. Glimpse: not reported.

• Independent read — Artificial Analysis scores G​emma 4 12B at an Intelligence Index of 14, ranked 20th of 141 models in its comparison class, with a measured output speed of 110.9 tokens per second. Glimpse has no independent score of any kind; it is one day old.

The Glimpse table also carries a footnote that a reader should not skip: those results use the highest thinking effort with the model's native agent harness, and for most video evaluations Sol and Opus 5.5 were run at high rather than max effort, with the HSS row mixing in paper-reported numbers from other labs. The same discipline applies on the other side — G​oogle's card numbers are published for the instruction-tuned checkpoints with no third-party harness involved.

What each one costs, and in what unit

This is where the shapes diverge hardest, because the units do not convert.

Glimpse is priced per token: $0.60 per million input tokens and $3.00 per million output. Elorian states the comparison itself — 94% below GPT-6 Astra at $10/$50, 85% below C​laude Opus 5.5 at $4/$20, 70% below GPT-6.1 Sol at $2/$10, and 20% below G​emini 3.8 Flash's $0.75/$3.75 introductory rate — and gives one task-level figure, a robot-planning episode costing $0.035 on Glimpse against $0.249 on Astra. All of those are the vendor's numbers about the vendor's model.

G​emma 4 12B has no vendor price because there is no vendor service. The only per-token figure that exists for it is Artificial Analysis's blended $0.10 per million input and $0.30 per million output, and that is a median across third-party platforms serving the open weights, not a list price — G​oogle publishes none. If you self-host, the number you actually care about is not a rate card at all. It is a 7 GB download, a GPU-hour, and the electricity.

Everything else follows from that. A Glimpse call has a marginal cost that scales with volume and a fixed cost of zero. A G​emma 4 12B deployment has a marginal cost near zero and a fixed cost that is a machine. The break-even point is a volume question, and no vendor will publish it for you.

Where this pair sits on our own catalogue

Neither model is a model OrcaRouter serves, and it is worth being blunt about that rather than letting the reader infer otherwise. Glimpse is reachable through Elorian's own API and chat interface; G​emma 4 12B is a download, and the hosted routes to it are third-party platforms running the open weights. The Gemma 4 sizes we do route are Gemma 4 26B A4B and G​emma 4 31B — the larger, more capable members of the same family — and if your actual question is "which G​emma 4 size should I call," our own model pages for those two will answer it faster than this page will.

Where a routing layer earns its place in this particular comparison is the middle case: a team that wants to keep running a G​emma 4 size it already self-hosts, and wants to trial an unproven preview alongside it without betting a production path on a model that shipped yesterday. Keeping both behind one endpoint means the preview sits behind automatic failover rather than in front of it, and a rate card that moves — which a research preview's will — is live on our side the same day rather than at the next contract renewal. That is a statement about how we operate, not a claim to host either of these two.

Choosing, given that they are not substitutes

If your work is temporal and your failure mode is "the model looked but did not look closely enough" — an object's identity across a cut, an event inside a sub-second window, a count that changes when something occludes — Glimpse is the first hosted model whose stated mechanism targets that directly, and the free sign-up makes the test cheap. Go and run your own clip through it. Then check the scratch space: if the model never re-scanned the interval that mattered, you have learned something about your pipeline and not just about the model.

If your work is to put a competent multimodal model on hardware you control — a laptop with 16 GB of memory per G​oogle's own claim, or a 24 GB card for the unquantised build — G​emma 4 12B is the mature, licensed, benchmarkable answer, and it has four months of community quantisations and tooling behind it that a one-day-old preview does not. That maturity is not a small thing: it is the difference between a model you can plan a quarter around and a model you can plan a week around.

The trap is picking Glimpse because its table beats Astra on four rows and then discovering the job needed reasoning, not re-scanning. The model's own HSS number is the evidence against that reading — 46.36 against Astra's 53.6, on a benchmark Elorian itself built with Scale AI. Publishing a result your own model fails to top is a credibility signal, and it also tells you precisely what the rewind does not fix.

None of that is hypothetical: 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.