Perceptron Mk1.5 vs Gemma 4 12B: One Answers in Sentences, the Other Answers in Coordinates

Here is the number that should stop you first: Perceptron Mk1.5 is a model built for video and embodied agents, and its context window is 36,864 tokens. Gemma 4 12B is a 12B open-weights generalist with a 256K window. On the axis most people use to compare vision models — how much footage can I hand it — the smaller, closed, purpose-built model loses by a factor of seven to the downloadable one. That inversion is not a flaw in either product. It tells you what each was actually built to do, and the two jobs are further apart than the shared "multimodal input" line on their spec sheets suggests.

Perceptron Mk1.5 is the embodied-reasoning model Perceptron shipped on September 25, 2026, the successor to Perceptron Mk1 from May, taking text, images, video and audio in and returning text plus machine-parseable geometry out. Gemma 4 12B is Google DeepMind's 11.96B encoder-free multimodal open-weights model, released June 3, 2026 under Apache 2.0, which takes text, image, audio and video in and returns text. Both are cheap, both read a camera feed, and only one of them will hand your controller a bounding box without a second parsing stage. The choice between them is a choice about what has to come back.

What each one is built to return

Put the two side by side and the difference is not accuracy. It is output type. Ask Gemma 4 12B where the forklift is and you get a sentence, and in most applications that sentence is the product — a description, a summary, an answer to a question about a photo. Ask Perceptron Mk1.5 and, alongside its prose, you can ask for a point, a bounding box, a polygon, a clip, or a <track> element that carries a spatial observation and the timestamp it belongs to. A 60-second clip comes back as a sequence of positions over time rather than one averaged guess about the scene.

That is the whole argument for Mk1.5 existing, and it is worth being precise about why it matters. A description of a scene is a finished artifact. A coordinate is an input to something else — a grasp planner, a defect check, a timestamped audit trail. If your downstream code has to read prose and infer position from it, you have built a parser between two models, and that parser is now your failure surface. Mk1.5's pitch is that the geometry arrives typed.

Gemma 4 12B's counter-argument is not that it does this too. It is that you can have the weights. Apache 2.0, 11.96B parameters, published in pre-trained and instruction-tuned variants, running on hardware you control, with a published evaluation card and a third-party index behind it. Those are different kinds of asset, and neither one substitutes for the other.

Where the two actually line up

Fewer places than the "multimodal 2026" label implies, but the shared ground is real and worth stating precisely because it is where a buyer's checklist usually starts.

• Input modality — both are genuinely four-modality. Perceptron Mk1.5 accepts text, images, video and audio (WAV, MP3, FLAC). Gemma 4 12B accepts text, image, audio and video through one encoder-free unified path.

• Output modality — neither generates audio or images. Both are text out. The difference is that Mk1.5's text can carry structured spatial annotations and Gemma 4 12B's does not.

• Function calling — both support it. Mk1.5 exposes function calling on chat completions and accepts constrained responses via JSON Schema and regex. Gemma 4 12B ships function calling in its instruction-tuned form and configurable thinking mode.

• Reasoning control — Mk1.5 replaces the old vision_config.enable_thinking boolean with a reasoning_effort field taking high, medium, low, minimal or none, and defaults to high. Gemma 4 12B exposes thinking and non-reasoning variants that score differently on the same harness because they do different amounts of work.

• Context — 36,864 tokens for Mk1.5 against 256K for Gemma 4 12B. This is the widest gap on the list and the next section is about it.

• Weights and licence — Mk1.5 is a closed hosted model with an SDK, not a download. Gemma 4 12B is Apache 2.0, so the hosted price is one option among several rather than the only way to run it.

The 36K window is a design decision, not a shortfall

An embodied model with a 36,864-token window sounds like a mistake until you look at what Perceptron built alongside it. Mk1.5 accepts an asset_idx field, so one request can reference several images or videos and address each separately. It caps audio at 16,384 tokens per item — Perceptron's docs put that at roughly 21.8 minutes of speech at about 750 tokens per minute. And the reason the window can stay small is that the task is narrow: find and track specific things in frames, answer about them, stop.

That is a different shape of work from Gemma 4 12B's. A 256K window is for holding a document, a repository, or a long conversation and reasoning across all of it. Mk1.5's window is a budget for one perception job with a structured answer, and Perceptron has sized it to that job rather than to a leaderboard. Where the difference bites is the moment your task is "watch this whole 40-minute inspection video and tell me everything" — a 36K window will not hold the transcript and the frames and the answer at once, and Gemma 4 12B's window plus its long-context recall score is the honest instrument for that.

The second half of that trade is speed. Perceptron reports up to 4.7× faster end-to-end from a median of three runs on a single H100, with the caveat that 4.7× is the best of three measurements and not the typical case: chat answers went 5.2 seconds to 1.1, image QA went 1.7 seconds to 0.51 (about 3.3×), and a 60-second video at eight-way concurrency went 19 seconds to 9.1 (about 2.1×). On the video workload an embodied agent actually runs, the honest multiple is roughly two.

One of these has been measured by somebody else

This is the cleanest asymmetry in the matchup and it is not close.

Gemma 4 12B has a vendor evaluation card and a third-party index. The card carries vendor-reported figures — MMLU Pro 77.2, GPQA Diamond 78.8, MMMU Pro 69.1, LiveCodeBench v6 72.0, AIME 2026 without tools 77.5, Tau2 averaged over three runs 69.0 — and one honest weak spot in MRCR v2 8-needle at 128k, which comes in at 43.4 and is the row to read before assuming a 256K window behaves like one at the far end. On top of that sits an independent measurement: Artificial Analysis puts Gemma 4 12B at an Intelligence Index of 14, ranked 22nd of 142 models in its class, at 113.7 output tokens per second — 20th of 142 on speed — with a list price of $0.10 input and $0.30 output per million tokens.

Perceptron Mk1.5 has nothing of the sort. There is no Artificial Analysis index entry and no arena score for Mk1.5 or for Mk1, so every capability figure that exists for this model was produced by the company selling it. That set is specific rather than vague, and it is worth reading: 0.9433 on egocentric hand_box against 0.4467 for Gemini 3.1 Pro and 0.6179 for the best Gemini in Perceptron's own run; EgoSchema 80.40 against 81.20 for the same competitor, a 0.80-point loss on the broad comprehension benchmark with a claimed 12% edge on the EgoSchema-hard subset at 63.75; 0.647 centre-F1 and 0.628 point-HOTA on Molmo2-Track; DailyOmni 74.67 and AVHBench 80.56 on the audio side. The pattern in those numbers — decisive on fine-grained geometry, roughly level or slightly behind on general video understanding — is coherent and it matches the product story. But a vendor's benchmark of its own model is a claim, and the two models in this article are not being described with the same kind of evidence.

One row in that table deserves a specific warning. Perceptron's tracking comparison lists Qwen3-VL-8B at 0.180 centre-F1, sourced from that model's paper, beside measured numbers for its own model, and pairs it with Qwen3.5-27B at 0.530 and 0.476 across different checkpoints and evaluation setups. A paper figure in a column of measured ones is not a like-for-like row, and it is the kind of line that gets quoted without its provenance. The same caution applies in reverse to the 56.0 Mk1.5 posts on LiveVQA-W with tools enabled — that figure comes from a four-sample majority vote, while the 53.2 it is compared against for Gemini 3.8 Flash with search grounding is not, and majority voting over four samples is a legitimate technique that flatters a score relative to a single greedy pass.

Costing an actual workload

The rate cards are closer than the products are. Perceptron Mk1.5 is $0.15 per million input tokens and $1.50 per million output, with cached input at $0.0375 — exactly a quarter of the standard input rate, and cheaper per cached token than Gemma 4 12B's $0.10 standard input. Gemma 4 12B is listed at $0.10 and $0.30 on the third-party harness that measures it, and it is Apache 2.0, so self-hosting removes the marginal cost entirely if you have the hardware.

Two things complicate a straight comparison and they point in opposite directions. First, Mk1.5's reasoning_effort defaults to high, which means every call you do not configure is buying the most expensive reasoning path the model offers; dropping to medium or low is a one-line change with a direct effect on the bill, and it is the cheapest experiment in the release. Second, Gemma 4 12B lets you switch the thinking step off altogether, which changes both the bill and the latency, and on a fixed task like frame-level classification a non-reasoning pass is often the correct one.

Run the arithmetic on something real: a vision pipeline processing 40,000 frames a day at roughly a thousand tokens of image input each. That is 40M input tokens daily. On Mk1.5's $0.15 input rate, with cached frames where the same scene recurs, you are in the low single-digit dollars a day for input — cheap by any standard. Gemma 4 12B at $0.10 input is cheaper still, and free at the margin if you self-host. Neither model is expensive. The decision here is not a budget decision; it is a question of whether you need coordinates, a 256K window, or both.

Calling both of them without a second integration

The practical obstacle to running this comparison is not price — it is that Perceptron Mk1.5 and Gemma 4 12B are not in the same catalogue. Neither is routed on OrcaRouter today: the Gemma 4 entries we serve are the 31B Instruct and 26B-A4B variants, and Mk1.5 has no route at all, so the honest guidance is to reach Mk1.5 through the vendor's own API at api.perceptron.inc — pip install "perceptron>=0.4.0", key in PERCEPTRON_API_KEY — and Gemma 4 12B either through a third-party host or by serving the Apache-2.0 weights yourself.

What a routing layer is genuinely for in this situation is the decision you have not made yet. If Mk1.5's structured output is what your application needs and Gemma 4 12B's window is what your other workload needs, those are two integrations and two failure domains; putting them behind one OpenAI-compatible endpoint with automatic failover means a provider hiccup on either side degrades into a fallback rather than a failed job, and a routing rule can send the geometry work and the long-context work to different models without your application knowing which is which. Where a vendor moves its rate card, a pass-through router bills the provider's list price with nothing added per token, so the change lands the same day rather than at your next billing cycle. The routing DSL is also how you would stage a comparison — a share of real traffic to each model, measured on your own frames, instead of a benchmark argument.

Which one you actually want

Take Perceptron Mk1.5 if the answer has to be machine-readable. If you are driving something, or logging something where position and time are the point, no amount of extra context window substitutes for a typed coordinate, and Mk1.5 is the only model in this pairing that produces one. Go in with your eyes open on three things: the 36,864-token budget, the high reasoning default, and the fact that every capability number attached to it is the vendor's own.

The cheapest way to settle it is to route a share of real traffic to each and measure on your own frames; both live behind one OpenAI-compatible endpoint on OrcaRouter, which is what makes a side-by-side test a config line rather than a second integration.

Take Gemma 4 12B if you need to hold a lot of material, if you need the weights, or if you need to justify the pick to somebody who does not take vendor benchmarks on faith. It has an independent index, a published evaluation card, Apache 2.0 licensing and a window seven times larger — and it will describe a scene rather than measure it. That last clause is the entire decision. One of these models is a generalist you can own and audit; the other is a specialist you rent because it returns geometry, and the fact that the specialist has the smaller window and no third-party score is not a contradiction. It is what a narrowly built tool looks like from the outside.