Mercury 3 vs NVIDIA Nemotron 3.5 Super VL 120B-A12B: One Speed Claim Is Measured, the Other Is Not

Mercury 3 and NVIDIA Nemotron 3.5 Super VL 120B-A12B are both sold on being fast. Only one of those speed claims has been checked by anybody outside the company that made it. Artificial Analysis measures Nemotron 3.5 Super VL at 434.3 output tokens per second on its own harness. Mercury 3, which Inception Labs released on October 19, 2026, claims 1,068 tokens per second — and as of October 20 there is no Mercury 3 page in that index at all, so the figure has no second party behind it. That asymmetry, not the spec sheet, is the actual decision in this matchup. 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.

There is a second asymmetry that matters more to some teams. Nemotron is downloadable, runs on your own hardware and can be post-trained. Mercury 3 is an API product with no weights. One of these is a procurement decision and the other is a deployment project, and the benchmark table is a poor guide to which you actually need.

The numbers both vendors agree on, and the one they do not

Start with the rows where the two stop looking different, because several of them are genuinely the same.

• Context — both are specified at 1M tokens. Mercury 3 pairs that with a 131,072-token output ceiling; Nemotron's card lists up to 1M of shared window across prompt, images, history, tool results and the answer.

• Output — text out, both. Neither generates images or audio.

• Input — this is where they part. Nemotron takes text, RGB images and MP4 video up to two minutes. Mercury 3 takes text, and only text.

• Price — Mercury 3 is $0.10 per million input and $0.35 per million output during its launch window, reverting to $0.20 and $0.70 at list. Nemotron has no vendor rate card at all; what exists is Artificial Analysis's costing sheet, which currently books it at $0.225 input and $0.575 output per million with a 78% cache discount and a cost of $0.19 per Intelligence Index task.

• Weights — Mercury 3's are not published and Inception has made no commitment to publish them. Nemotron's are on Hugging Face under OpenMDW-1.1, with full-precision and NVFP4 checkpoints.

That last row is the one that decides most real evaluations, and it has nothing to do with tokens per second.

Reading the independent index without overreading it

NVIDIA shipped Nemotron 3.5 Super VL on October 15, 2026. When the first independent scoreboard appeared that same week, it carried an Intelligence Index of 26 and a blank where the speed column should have been. The page now carries both: 26 on Index v4.3.2, and 434.3 output tokens per second, which ranks it first among the 28 models in its comparison class. It also generated 170M tokens across the index run, against a median of 100M, which the page describes as somewhat verbose.

Those are the index's own measurements, run through its own harness, and they are worth exactly what any single benchmark suite is worth: a reproducible number collected by someone who does not work for NVIDIA. Note what 26 does and does not mean. The page's own comparison text puts it against a median of 8 for comparable open-weight models in the 40B–150B class, so it is a strong result within its weight class and a modest one against frontier models of any size. The ranking of first-of-67 that appears at the top of the page is a ranking inside a filtered class, not an overall placement. Anyone quoting "number one" without the filter is quoting the filter.

Now the other side. Inception's launch post makes three quantitative claims: 1,068 tokens per second on NVIDIA GPUs, a 1M context, and a launch price half the list rate. It makes no numeric quality claim at all. Instead it says Mercury 3 "outperforms GPT-6 Luna and Claude Haiku 5.5" — two speed-optimised models, which is the correct comparison set for a latency product, stated without a margin, a benchmark name or a per-task result. It also reports that Mercury 3 completed 50% of 50 live Mind2Web navigation tasks inside Inception's own web-agent harness, "significantly more than GPT-6.1-Sol". Fifty tasks on a vendor harness is a signal, not a measurement you can put beside 26.

So the honest comparison of quality evidence is this: one model has a third-party index score and the other has a vendor sentence. That does not make Mercury the weaker model. It makes it the unmeasured one, and unmeasured is a different risk category from low-scoring.

What the open-weights half actually costs to run

Nemotron 3.5 Super VL is a 120B-parameter mixture-of-experts model with 12B active per token, 512 routed experts per MoE layer, and a hybrid backbone that interleaves Mamba-2, attention and MoE layers with a C-RADIO vision encoder bolted on through a connector. NVIDIA ships it in two precision tiers, and the gap between them is the most useful number in the release.

• BF16 — 64 safetensors shards, roughly 231.8 GiB. NVIDIA's own serving recipe is tensor-parallel 4 on four H100s, or TP2 on two GB200s.

• NVFP4 — 4-bit weights and activations with quantisation-aware distillation. The card lists deployment on one DGX Spark, one H200, two H100s or one GB200.

A 120B model that fits on two H100s at 4-bit instead of four at BF16 is a different purchasing conversation, and it is why the quantised checkpoint is the one the vendor points at for efficient serving. What NVIDIA does not publish is an accuracy side-by-side between the two tiers. The claim is a training-methodology claim — that distillation during training closes the quantisation gap — not a measured comparison, and if your decision turns on that gap the answer is not in the repo.

The licence is worth reading past the marketing. The blog post says "open weights"; the card's frontmatter says license: other, license_name: openmdw-1.1, governed by the OpenMDW License Agreement 1.1. Commercial use is permitted and the card says so plainly. It is not Apache 2.0, and if your organisation keeps an approved-licence list, that list is the thing to check before the GPU quote.

Where the two stop being substitutes

The mismatch is not quality. It is the shape of the job.

Mercury 3 is a diffusion language model — Inception's term is dLLM — that generates tokens in parallel rather than one at a time, which is where a four-figure throughput claim comes from in the first place. The workload it is built for is one where a human is watching: tutoring hints, search generation, a support reply that has to feel conversational. Inception's own customer quotes are all of that kind, and they are the right test of the product. A wrong hint is recoverable. A two-second pause is not.

Nemotron 3.5 Super VL is built for the opposite end. It reads screenshots, scanned documents, charts and two-minute video clips, calls tools, and runs on hardware you control. The workload it is built for is a pipeline that runs for minutes and reports back, where a wrong extraction is expensive and a five-second wait is invisible. Its own card is candid that the multimodal benchmark rows were not all run through the open tooling NVIDIA publishes, and that the internal scaffolding behind several of them is promised for a future release. That caveat does not disqualify the model; it tells you which rows to re-run yourself before you depend on them.

The overlap is narrower than the spec sheets suggest. If your input is a stack of invoices, a product video or a dashboard screenshot, Mercury 3 cannot see it. If your requirement is a sub-second conversational turn on plain text, a 120B multimodal checkpoint on your own GPUs is a very expensive way to get one.

Neither model is on our catalogue, and that changes the routing advice

Both of these are honest negatives. Our model API returns no Inception model and no NVIDIA Nemotron entry, so neither Mercury 3 nor Nemotron 3.5 Super VL is something you can call through us today. Anyone who wants Mercury 3 goes to Inception's own platform, which gives new accounts 100 million free tokens; anyone who wants Nemotron downloads the checkpoint from Hugging Face or uses a third-party host. We would rather write that down than imply a route we do not have.

What a routing layer is still good for here is the part around the experiment. A two-path arrangement is the sane way to evaluate an unmeasured model: send the latency-critical tier to Mercury 3 through Inception's key, and keep the fallback and the hard cases on models we do carry — more than 200 of them behind one OpenAI-compatible endpoint, at provider list price with 0% markup, with automatic failover when a provider degrades. If the new path turns out to be worse than the launch post suggested, the fallback is already wired and the switch is a routing rule rather than an integration project. The self-hosted half of the comparison gets nothing from any of that, because there is nothing to route.

The decision rule

Pick Nemotron 3.5 Super VL 120B-A12B when the model has to see something — a page, a scan, a clip — or when the data cannot leave your infrastructure, or when you intend to post-train on your own examples. Budget for the hardware honestly: four H100s at BF16 or two at NVFP4 is a real capital commitment, and the 26 on the index is a class-relative score, not a frontier one. Accept that its instruction-following and long-context rows are the weaker part of its own table.

Pick Mercury 3 when a person is waiting on a text answer and a retry costs nothing. Accept two things before you build on it: that 1,068 tokens per second is a vendor number with no independent reproduction, and that the default effort setting is "low" — so any benchmark you run yourself is only comparable to someone else's if you pin instant, low, medium or high explicitly. Budget at list price, $0.20 and $0.70, because the launch discount has no published end date and a cost model built on $0.10 and $0.35 has an expiry you cannot see.

What would change the answer fastest is the same thing on both sides: a second party running the same tests. If Artificial Analysis publishes a Mercury 3 page, the throughput claim becomes checkable and the quality question stops being a sentence in a launch post. If NVIDIA publishes an accuracy delta between BF16 and NVFP4, the cheap deployment tier stops being a leap of faith. Until either lands, the truthful summary is that one of these models has been measured and the other has been described, and no amount of spec-sheet comparison closes that gap.