On October 19, 2026, Inception Labs released Mercury 3, its fourth-generation diffusion-based large language model. Two numbers do most of the attention-grabbing: 1,068 tokens per second of output on NVIDIA GPUs, and 8 wins out of 12 capability benchmarks against the strongest available competitors. If both survive third-party scrutiny, the crown for output speed changes hands. The operative word is "if" — and unpacking it is most of what this review does.
A scope note first: this site's model-speed coverage (the local LLM deployment series) deals with open-source models you run yourself; Mercury 3 is a closed-source API product — different lane. There is no prior diffusion-LLM comparison on this site either, making this the first. One discipline note: every benchmark figure below comes from Inception's own published comparison table and is labeled "Inception-reported" throughout. Artificial Analysis, the third-party evaluation house most often cited in this space, had not added the model at publication time. That fact hangs over every number here.
Diffusion LLMs, Explained: Typewriters and Polaroids
Nearly every mainstream large language model today is autoregressive. It works like a typewriter: one token at a time, left to right, and the streaming output you watch is that typewriter hitting keys. The speed ceiling follows from the design — no matter how fast the machine, it types one token at a time.
Diffusion models take a different route, closer to a Polaroid photograph. The starting point is not a blank page but an entire block of masked text; each denoising round is like a development pass that fixes multiple positions in parallel; round after round, the whole picture sharpens. A single round costs more compute than one autoregressive step, but each round can lock in many tokens at once, so throughput depends on how many positions get committed per round. That structural difference is why diffusion LLMs have a plausible path to winning on speed.
The mechanism also has a property latency-sensitive applications should care about: autoregressive latency stacks linearly with output length, while a diffusion model's round count is not strictly tied to length — rounds can in principle be compressed by committing more positions per pass. The cost is equally clear: the more positions per round, the harder the scheduling and quality control — one reason diffusion LLMs stayed at small scale for years. Mercury 3 pushing context to 1M tokens while benchmarking at flagship tier is an answer sheet submitted for the question "can the diffusion route carry the flagship load," and the rest of this review grades it.
That question had been the field's open wound: do diffusion models keep up on quality as they scale? Autoregressive models have scaling laws as a safety net; diffusion models had no evidence at comparable scale. Inception's claim is that Mercury 3 settles it — the autoregressive scaling laws hold for diffusion too. Founder Stefano Ermon went further: "The limits of diffusion models are compute and data, not any fundamental barrier in the algorithm itself." Whether that settles anything depends on third-party follow-up.
Back to the product. Context now extends to 1M tokens, up from 260K in Mercury 2.5 — roughly a fourfold expansion. Output is capped at 131,072 tokens. Parameter count is undisclosed; the company says only that the model is more than 40 times larger than Mercury 1. File that under the same "self-reported" ledger as everything else.
12 Benchmarks: 8 Wins, 4 Losses
Inception's comparison table pits Mercury 3 against GPT-6 Luna (medium) and Claude Haiku 5.5 (medium), with reasoning effort matched across the board. All 12 capability benchmarks were run by Inception itself. The medium-tier results:
| Benchmark | Mercury 3 | Best rival | Gap |
|---|---|---|---|
| SWE-Bench Atlas | 51.08 | 33.33 (Luna) | +17.8 |
| IFBench | 76.84 | 61.82 (Luna) | +15.0 |
| MultiChallenge | — | — | +7.9 |
| tau3-bench Banking | — | — | +7.2 |
| DeepSearchQA | — | — | +6.1 |
| BrowseComp+ | — | — | +4.7 |
| GPQA Diamond | 89.23 | 86.36 (Luna) | +2.9 |
| GDPval | 1237.2 Elo | 1225.0 | +12.2 |
| AA-Omniscience | — | — | -0.5 |
| AA-LCR v1.1 | — | — | -0.6 |
| MRCR v2 | — | — | -2.9 |
| DeepSWE v1 | — | — | -5.3 |
Among the 8 wins, the largest gap is SWE-Bench Atlas: 51.08 against Luna's 33.33 and Haiku's 32.26, a 17.8-point lead on a benchmark built from real software engineering work. IFBench (instruction following) follows at +15.0. GPQA Diamond is a narrow 89.23 versus 86.36; GDPval at 1237.2 versus 1225.0 Elo is another slim margin. The middle band — MultiChallenge +7.9, tau3-bench Banking +7.2, DeepSearchQA +6.1, BrowseComp+ +4.7 — narrows steadily. The overall shape: large leads on coding and instruction following, small leads on reasoning and knowledge.
The 4 losses must be listed in full; that is the minimum duty of any honest comparison. AA-Omniscience falls 0.5 points short, AA-LCR v1.1 by 0.6, MRCR v2 (multi-turn long-context consistency) by 2.9, and — most worth flagging — DeepSWE v1 by 5.3. Note the structure: on coding, Mercury 3 crushes Atlas by 17.8 yet loses DeepSWE by 5.3. Two "strongest coding benchmark" candidates sending opposite signals means coding strength is uneven across task distributions, and any vendor narrative built solely on Atlas deserves a question mark.
A quick gloss: SWE-Bench Atlas and DeepSWE test real software engineering; IFBench, instruction following; MultiChallenge, multi-turn misdirection resistance; tau3-bench Banking, tool calling under business rules; DeepSearchQA and BrowseComp+, deep retrieval; GPQA Diamond, graduate-level science; GDPval, economic task output in Elo; MRCR v2 and AA-LCR, long-context consistency; AA-Omniscience, knowledge breadth. Read that way, the 8 wins cluster in the agent execution path — coding, tool calling, browsing, instruction following — precisely where low latency is worth the most money, and the 4 losses cluster in long-context consistency and knowledge breadth, where speed buys nothing. That alignment says more than the raw win count.
One data point outside the table: on Mind2Web, Mercury 3 completed 50 percent of 50 real browser tasks, which Inception says is significantly higher than GPT-6.1-Sol at the same token budget and step limit. Source: a vendor-built harness, not an independent reproduction. Apply the discount rules from the next section.
Pricing and Access: Reading the Fine Print on the Half-Price Launch
Two pricing lines, stated plainly. Standard: $0.20 input and $0.70 output per million tokens. Launch promotion at half price: $0.10 and $0.35. Cached input is a tenth of the input rate: $0.02 standard, $0.01 promotional.
One easily missed detail: the capability comparison table Inception published carries a cost comparison alongside it, computed at the half-price promotional rate. The promotion is temporary; the standard rate is the steady state. Budgeting from the table's cost figures means planning long-term spending against a price that expires.
More glaring is the single-number comparison: the $0.70 standard output rate is above GPT-6 Luna's $0.50. In other words, on the output side — exactly where a diffusion architecture should, in theory, have the strongest cost story — the everyday price is 40 percent higher than the rival it benchmarks against. Whether the speed advantage cancels the price disadvantage depends on your workload: throughput-sensitive, short-output agent loops may come out ahead; long-form generation may not.
The cached-input rate matters more than it looks for agent workloads: system prompts, tool definitions, and long-running memory get resent with nearly every request, and a cache hit divides that slice of the bill by ten — in practice often a larger slice than the non-cached portion. Price your real workload with that line item separated out.
Access: Inception's own API, OpenRouter (model name inception/mercury-3-20261019), Baseten, Vercel AI Gateway, and the Mercury Chat web app. The API is OpenAI-compatible — existing projects switch by changing the base URL and model string. Every new API key ships with 100 million free tokens, worth a few hundred dollars at the promotional input rate, enough to run whatever you want to verify.
The Caveat Ledger: How Much Discount to Apply
First discount: every number comes from Inception's own published table, and Artificial Analysis has not listed the model. Until AA runs it, there is no third-party score and no independent reproduction — every result you have seen is the vendor grading its own exam.
Second discount, the heaviest one: the track record. When the previous-generation Mercury launched, it made similarly aggressive speed claims; in Artificial Analysis' later testing it delivered roughly 60 percent of the advertised speed (per aibacon). The gap between a vendor's test environment and third-party end-to-end latency is systematic, not conspiratorial, and for this company it has already happened once. Both "1,068 tokens per second" and "4 to 8 times faster" should be mentally discounted in advance; the competitor side of that speed comparison is equally unverified end-to-end.
Third discount: the "3 times more intelligent" talking point is a vertical comparison from Mercury 1 to Mercury 3 — the vendor against its own three-generations-old model. As marketing it is fine; as a purchasing signal it is nearly worthless.
Fourth discount: all customer testimonials are secondhand, quoted from the press release — TinyFish AI (browser agents), RevisionDojo (about one second for educational feedback), Octen AI (0.9-second median generation, 2.2 seconds end-to-end on smart glasses), Lorikeet (support-desk latency). None was independently interviewed; they establish that companies are using the product, not how well it works.
Closed-Source by Design: One Flagship and Two Side Lines
The classification must be stated plainly: Mercury 3's weights are not public, there is no technical report, and the parameter count is undisclosed (the company says only that it is more than 40 times larger than Mercury 1). This is a closed-source API model. Two consequences follow. First, the pivotal claim — that quality scales for diffusion the way it does for autoregression — cannot be examined at the architecture or training level by outsiders; the only path to verification is third-party benchmarking. Second, all usage is bound to Inception's service and pricing, with no self-hosting escape hatch. For teams that treat "no single-vendor lock-in" as a hard requirement, this one line is a veto.
The product line, briefly. Mercury Voice targets voice agents with sub-170ms first-token latency (Inception-reported) at $0.40/$1.50 per million tokens; Mercury Decide is a decision model with calibrated probabilities and an escalation-to-human switch, claimed to beat Jev on JevBench and LegalBench — self-reported again. Mercury 2 and 2.5 stopped accepting new customers (existing ones served until November 15); factor migration cost into any procurement decision.
Verdict: Who Should Try It Now, and Who Should Wait
Try it now if low latency and high throughput are hard constraints: real-time voice interaction, smart-glasses-class assistants, customer support and education with instant feedback, and high-frequency short-output agent pipelines. For this group, speed is the product experience, the 100 million free tokens make the experiment roughly free, and the OpenAI-compatible interface makes switching cheap too. When the answer is that cheap, ask the question.
Wait if you are budget-sensitive or doing long-output generation (the $0.70 standard output rate is sitting right there, and the half-price window will close), if you need self-hosting or weight audits (closed source; no options), or if you are making any production commitment worth real money — at minimum wait for Artificial Analysis to list the model. A company whose previous product measured at six-tenths of its advertised speed has earned one extra round of independent verification.
One-line summary: Mercury 3 moves the evidence chain on "can diffusion LLMs carry the flagship load" a large step forward, and the 8-of-12 benchmark structure carries more weight than the raw speed number. But the entire chain has exactly one source — Inception. Whether the speed crown changes hands will be decided by third parties, not a press release.
FAQ
Q1: Is Mercury 3 an open-source model?
A1: No. Weights are not public, there is no technical report, and the parameter count is undisclosed (only "more than 40 times larger than Mercury 1"). It is a closed-source API model — Inception API, OpenRouter, Baseten, Vercel AI Gateway — with no self-hosting option. For teams needing self-hosting or weight audits, this is a hard disqualifier.
Q2: Can the 1,068 tokens-per-second figure be trusted?
A2: It is an Inception-reported figure from a specific NVIDIA GPU environment; Artificial Analysis has not listed the model, and competitor end-to-end latency is unverified. The track record matters most: the previous-generation Mercury measured at roughly 60 percent of its advertised speed in AA testing (per aibacon). Discount self-reported numbers accordingly and wait for independent tests.
Q3: Does 8 wins out of 12 benchmarks mean it crushes the competition across the board?
A3: No. The 4 losses deserve equal billing: AA-Omniscience -0.5, AA-LCR v1.1 -0.6, MRCR v2 -2.9, and DeepSWE v1 -5.3. The coding picture is mixed: a 17.8-point win on SWE-Bench Atlas alongside a 5.3-point loss on DeepSWE means coding strength is uneven across task distributions. All 12 benchmarks are Inception-run with no third-party reproduction.
Q4: How does pricing actually work, and is the half price permanent?
A4: Standard rates are $0.20 input and $0.70 output per million tokens; the launch promotion halves them to $0.10/$0.35; cached input runs at a tenth of the input rate ($0.02 standard, $0.01 promotional). The half price is temporary. Two cautions: the cost comparison attached to Inception's own benchmark table is computed at the promotional rate — re-budget at standard rates for the long term; and the $0.70 standard output rate is above GPT-6 Luna's $0.50.
Q5: Which teams should jump in and test it right now?
A5: Latency-sensitive use cases: real-time voice interaction, smart-glasses assistants, instant feedback in education or customer support, and high-frequency short-output agents. New API keys come with 100 million free tokens, and the OpenAI-compatible interface switches over with a base URL change — trial cost is near zero. For budget-sensitive long-form generation or production decisions with real money attached, wait until Artificial Analysis lists the model.
Related reading
- MiniMax M3.1 Flash Unmasked: Space Bunny Ran 200T Tokens: MiniMax M3.1 Flash Unmasked: Space Bunny Ran 200T Tokens
- Local LLM deployment compared: five routes field-tested: Local LLM deployment compared: five routes field-tested
- Taste-Bench: Only GPT Models Beat a Coin Flip on Taste: Taste-Bench: Only GPT Models Beat a Coin Flip on Taste