Mercury 2 Guide: How a Diffusion Reasoning Model Gets Its Speed

Every mainstream language model writes the same way: one token, then the next, then the next, each waiting for the one before it. Most speed work in the last few years has been about making that loop cheaper. Mercury 2 is interesting because it does not run that loop at all.

Inception launched Mercury 2 on 24 February 2026 and called it the first reasoning diffusion language model. It is a hosted, text-in, text-out model with a 128K context window, tool use and schema-aligned JSON output, served behind an OpenAI-compatible API. Inception lists it at $0.25 per million input tokens and $0.75 per million output.

How a diffusion model writes

An autoregressive model commits to each token permanently and moves on. Generating 500 tokens takes 500 sequential forward passes, however powerful the GPU, because each step depends on the last. How LLMs actually work walks through that loop.

A diffusion language model starts from a rough draft of a block of text and refines many positions at once over a small number of steps. Inception compares it to an editor revising a whole draft rather than a typist producing one word at a time. Each refinement pass touches many tokens in parallel, so the number of sequential steps is decoupled from the length of the output.

That is the same idea that made diffusion dominant in image generation, applied to text. The difficulty has always been quality: text is discrete and unforgiving in a way pixels are not, and earlier diffusion text models trailed autoregressive ones of similar cost. Mercury 2's claim is that it has closed enough of that gap to support reasoning.

What the speed numbers do and do not say

Inception reports 1,009 tokens per second on NVIDIA Blackwell GPUs. In a launch comparison reported by The Decoder, it gave Mercury 2 an end-to-end latency of 1.7 seconds against 14.4 seconds for Gemini 3 Flash and 23.4 seconds for Claude Haiku 4.5, both with reasoning enabled.

Three caveats before you plan around those figures:

• They are vendor measurements. Inception chose the hardware, prompts and settings.
• Tokens per second is not the same as latency. For short replies, time to first useful output and network overhead can dominate. Tokens per second explained covers how to read the number.
• Reasoning changes the count. A reasoning model writes hidden tokens before its answer, so a fast model that reasons at length can still take a while. Mercury 2 offers tunable reasoning for that reason.

Even with those discounts, the end-to-end gap Inception reports is large, and the architecture gives a plausible reason for it. That makes it worth measuring rather than dismissing.

The quality trade

Inception positions Mercury 2 as comparable to leading speed-optimised models, not to frontier ones. The launch table, as reported by The Decoder, gave it 74 on GPQA Diamond, 67 on LiveCodeBench, 38 on SciCode, 71 on IFBench, 91 on AIME and 53 on tau-bench. In the same table Gemini 3 Flash with reasoning scored higher on GPQA Diamond at 90.

Read that as a model in the fast, cheap tier with competent reasoning, not a replacement for a large model on hard problems. The useful question is not whether it is as smart as your best model, but whether it is smart enough for the specific calls in your pipeline that are bottlenecked on latency.

Where it fits in a stack

Inception targets workloads where many model calls sit on the critical path: coding autocomplete and next-edit suggestions, agent loops with dozens of calls per task, voice assistants, and search or RAG pipelines doing retrieval, reranking and summarisation.

The common thread is that a human or another system is waiting, and the per-call quality bar is moderate. A voice agent that answers in under two seconds with a good answer beats one that answers in fifteen with a slightly better one. A coding agent that compacts its context or summarises tool output with a fast model spends its slow, expensive calls only where they matter. Best model for low latency covers how to identify those calls.

It is a poor fit where the hardest reasoning is the bottleneck, or where you need to own the weights. Inception distributes Mercury 2 through its hosted API and partners rather than as a public download, so plan on calling it as a service.

Mercury 2 now that 2.5 exists

Inception released Mercury 2.5 in September 2026 with a 260K context window, a claimed 40% intelligence gain, and a list price of $0.20 input and $0.75 output per million tokens: cheaper on input, the same on output. The Mercury 2.5 guide covers what changed.

On paper that leaves few reasons to start new work on Mercury 2. The reasons to stay are practical ones. If you have evaluations, prompts and latency budgets tuned to Mercury 2 and they pass, moving is a change to test rather than a free upgrade. Pin the model ID, run your evaluation set against 2.5, and switch when the numbers say so.

If you are evaluating diffusion models for the first time, start with 2.5 and use Mercury 2 only as a baseline. Either way, measure the thing the architecture claims to fix: wall-clock time per completed task under your real concurrency, alongside accuracy. Latency-adjusted model scoring shows how to combine the two into one number.