The 3-second answer
No single model is "fastest" at everything. In July 2026 the verified throughput leader for production-grade reasoning is Mercury 2 by Inception Labs, independently benchmarked at 789–1,009 tokens/second (Artificial Analysis measured 789–953 t/s; Inception's own Blackwell number is 1,009 t/s). That is roughly 5–10x faster than GPT-5.6 and Claude Opus 5 on the same generation workload, and it costs $0.25/$0.75 per 1M tokens — about 40x cheaper on output than frontier models. But Mercury 2 sits in the Claude 4.5 Haiku / GPT-5.2 Mini quality tier, not the frontier tier: on GPQA Diamond it scores ~74 and on AIME 2025 ~91, while GPT-5.6 Sol leads reasoning boards at 94.6% GPQA. The fast model is not the smartest model. The smart move is to route based on what the call actually needs.
A viral YouTube video framed this story as "Selerus-1 beats ChatGPT-5 at 1280 wps / 157ms response / 76% MMLU-Pro." After checking every one of those numbers against Mercury's launch post, the Google DeepMind DiffusionGemma launch, and the Artificial Analysis / LLM Leaderboard trackers, three of those four claims are inflated or unsourced, and the model name "Selerus" returns zero hits anywhere. The substance — that diffusion-based text generation is now the fastest production paradigm — is real. The exact numbers deserve scrutiny. Here's what's actually true and what to do about it.
What the video gets right (and what it doesn't)
The video's core thesis is correct: a new class of LLM uses diffusion instead of autoregressive decoding, and it is dramatically faster at token generation. Here is every specific claim, fact-checked:
| Video claim | Verified reality | Verdict |
|---|---|---|
| Diffusion-based text model beats ChatGPT-5 on speed | Mercury 2 (Inception Labs, Feb 24 2026) and DiffusionGemma (Google, Jun 10 2026) are real diffusion LLMs. Mercury 2 is independently ranked #1 for output speed. | True (the paradigm shift is real) |
| 1280 words/sec (≈1600 tok/s) | Artificial Analysis measures Mercury 2 at 789 tok/s median across its API; Inception's internal Blackwell benchmark peaks at 1,009 tok/s. No public source supports a sustained 1,600 tok/s figure. | Inflated — real number is 789–1,009 tok/s |
| 157ms time-to-first-token | Mercury 2's measured TTFT is 3.4–4.0 seconds (it's a reasoning model; the first chunk is reasoning output). Sub-200ms TTFT is autoregressive small-model territory (Command A+ at ~250ms). | Not supported by primary data |
| 76% MMLU-Pro | Mercury 2's MMLU-Pro score is not officially published; the AA Intelligence Index is 21.4 and GPQA Diamond is 74. No source confirms 76% MMLU-Pro. | Unverifiable — no primary source |
| Beats ChatGPT-5 ("81% MMLU-Pro") | On reasoning GPT-5.6 Sol leads at 94.6% GPQA Diamond per LLM Leaderboard; on MMLU-Pro top of board is Gemini 3 Pro at 89.8%. Mercury 2 is not in the frontier reasoning tier — it targets the speed-optimized tier. | Misleading — different quality tier |
The honest synthesis: the direction of the video is right, the specifics are inflated, and conflating "fastest throughput" with "beats GPT-5.6 on reasoning" is a category error. Mercury 2 is the fastest; GPT-5.6 Sol is the smartest. They are not the same model.
How diffusion LLMs actually work (and why the speed jump is real)
Every ChatGPT-class model you have used since 2022 is autoregressive: it generates one token, then the next, then the next — strictly left-to-right. The bottleneck is memory bandwidth: each token requires a full forward pass that reads all the model weights from GPU memory, and that read happens once per token. This is why a 70B model on an H100 tops out around 80–120 tok/s even though the GPU has vast spare compute.
Diffusion LLMs flip this. Instead of decoding left-to-right, they:
- Start with a block of random "noisy" tokens (think of it as static on a page).
- Refine the whole block in parallel, in a small number of denoising passes (typically 10–20). Every token can attend to every other token, so context flows both directions.
- Converge to coherent text — the same way image diffusion models like Stable Diffusion converge from noise to a picture, but in token space.
The throughput win is structural. An autoregressive model does N forward passes for N tokens; a diffusion model does ~10–20 passes regardless of block size. DiffusionGemma produces 256 tokens per pass, so 256 tokens cost roughly 20 forward passes, whereas an autoregressive model would need 256. The math favors diffusion harder the longer the block.
There is a catch, and Google says so directly in the DiffusionGemma launch post: because each pass touches the whole block, overall output quality is lower than the equivalent autoregressive Gemma 4. Google recommends standard Gemma 4 when you need maximum quality. Diffusion is a speed-first trade.
The verified benchmark table (July 2026)
Pulled from Artificial Analysis, LLM Leaderboard, PricePerToken, and the official Inception / Google launch posts. Speed numbers are independently measured median tok/s on the provider's API, not vendor claims.
| Model | Maker | Speed (tok/s) | TTFT | GPQA Diamond | AIME 2025 | Price in/out ($/M) | Quality tier |
|---|---|---|---|---|---|---|---|
| Mercury 2 | Inception Labs | 789–1,009 | 3.4–4.0s | ~74 | 91.1 | $0.25 / $0.75 | Speed-optimized (Haiku / GPT-5.2 Mini class) |
| DiffusionGemma 26B-A4B | Google DeepMind | 1,000+ (H100) | — | — | — | Open (Apache 2.0) | Below Gemma 4 quality |
| GPT-5.6 Sol | OpenAI | ~74 | <1s | 94.6 | — | $5 / $30 | Frontier |
| Claude Opus 5 | Anthropic | ~48 | <1s | 94.4 | — | $5 / $25 | Frontier |
| Gemini 3 Pro Preview | — | — | 89.8 (MMLU-Pro) | — | — | Frontier | |
| Llama 4 Scout | Meta | 2,600 (claimed) | — | — | — | — | Speed-optimized |
| Nemotron 3 Super 100B | NVIDIA | 367 | 0.71s | — | — | — | Mid-tier |
| GPT-OSS 20B | OpenAI | 313 | 0.65s | — | — | Open | Mid-tier |
Read this table carefully. Mercury 2 is ~10x faster than GPT-5.6 Sol on raw generation. But GPT-5.6 Sol is ~20 points ahead on GPQA Diamond (94.6 vs ~74). On long-context reasoning, agentic coding (SWE-Bench), and frontier math, the autoregressive giants still win. On raw token spraying, voice agents, autocomplete, and real-time RAG reranking, diffusion wins decisively.
The builder's routing playbook (what to actually do)
This is the part the video skips. "Fastest" is only useful if you route the right call to the right model. Here is the decision tree we use at shaam.blog for our own agent stack.
1. Use Mercury 2 / diffusion when latency compounds
In agentic loops, every step's latency adds. A 10-step agent loop at 4 seconds per step is 40 seconds of wall-clock — most users bounce. Mercury 2's 1.7-second end-to-end (Inception's measurement) makes 10-step loops feel instant. If you are building anything that loops — retrieval pipelines, multi-step extraction, agentic coding, voice — route the steps that don't need frontier reasoning to Mercury 2.
This maps directly to the pattern we wrote about in our AI Agent Loop Cost guide: cheaper to run a cheap builder and a strong judge than one frontier model. Mercury 2 is the cheapest "builder" step we have measured; pair it with GPT-5.6 or Claude Opus 5 as the "judge" and you cut loop cost without sacrificing final-answer quality.
2. Keep GPT-5.6 / Claude Opus 5 for the reasoning-heavy steps
The final answer in an agent loop — the one a user reads — still benefits from the frontier model. GPT-5.6 Sol's 94.6 GPQA is not marketing; it's a real jump on hard reasoning. Use frontier for: synthesis, math-heavy analysis, multi-hop reasoning over a large context, code generation that has to compile, the last step of a RAG pipeline where the answer has to be right.
3. Use DiffusionGemma when you need open weights and local control
DiffusionGemma is Apache 2.0 and fits in 18GB VRAM. If you are self-hosting (compliance, privacy, cost predictability) and your workload is in-line editing, code infilling, autocomplete, or any task where bi-directional attention is an asset, DiffusionGemma on a quantized RTX 5090 gives you 700+ tok/s with no per-token bill. We covered a related self-hosting pattern in How to build a free local AI agent with Gemma 4 and Hermes; DiffusionGemma slots into the same stack.
4. Stop comparing models on a single axis
The most common mistake in 2026 is ranking models on tokens/second alone, or on MMLU-Pro alone, as if one number captures "better." It does not. The right frame is a 2D plot: speed (x) vs quality (y), with price as bubble size. Mercury 2 sits in the top-left (fast, mid-quality, cheap). GPT-5.6 is in the bottom-right (slow, top-quality, expensive). Neither dominates. The optimal stack uses both.
If you want the full model-agnostic cost framework — switching providers per request, caching layers, blended routing — we wrote the playbook here: How to optimize LLM costs with a model-agnostic architecture.
What "ChatGPT-5 beating" actually means in 2026
Naming has gotten muddy. When the video says "ChatGPT-5," it maps to the OpenAI GPT-5.x line that is live as of July 2026 — most precisely GPT-5.6 Sol, which launched July 9 along with Terra and Luna variants. The GPT-5.6 line tops the reasoning leaderboard. On raw throughput, even the mini variant of GPT-5.6 is nowhere near Mercury 2; that is an architectural fact of autoregressive decoding.
The honest read: diffusion LLMs have not "beaten" ChatGPT-5 in the sense the video implies. They have beaten autoregressive models at the speed-vs-cost-vs-quality trade-off for a specific class of latency-sensitive workloads. That is a real and commercially important win, and it is enough to reshape how you route traffic. It is not a knockout.
Where this goes next (and the small business angle)
Three things to watch in the back half of 2026:
- Quality closure. Diffusion's quality gap is closing. The DiffusionGemma team and Inception are both actively working on it. If diffusion closes to within 5% of autoregressive Gemma 4 quality, the routing math flips for most workloads.
- Infra. Mercury 2's 1,009 tok/s is on Blackwell. As Blackwell installs scale, the per-token cost of diffusion drops further. NVIDIA is leaning in (their official quote in the Mercury 2 launch post calls out the partnership).
- Open ecosystem. DiffusionGemma being Apache 2.0 means quantized variants, fine-tunes, and llama.cpp / vLLM integrations are landing through the summer. Local-first shops get a real speed option without a vendor.
If you run a small business and want a practical read on which AI updates actually matter this month, we track those here: Google's July 2026 Gemini updates: 3 new models, an always-on agent, and smarter video. The diffusion story is part of that same wave — the bigger pattern is that the model layer is fragmenting by workload rather than consolidating on one "best" model.
FAQ
Is Mercury 2 actually faster than ChatGPT-5? Yes, at generating text. Artificial Analysis independently measures Mercury 2 at ~789 tokens/second vs GPT-5.x at ~74 tok/s — roughly a 10x gap. On reasoning-quality benchmarks (GPQA Diamond, SWE-Bench) GPT-5.6 Sol is still ahead. Speed and quality are different axes.
What is a diffusion LLM? A diffusion LLM (dLLM) generates text by starting with a block of random tokens and iteratively denoising them in parallel over 10–20 passes — the same principle as image diffusion models like Stable Diffusion, but in token space. This is fundamentally different from autoregressive models (ChatGPT, Claude, Gemini), which generate one token left-to-right.
Can I use Mercury 2 today? Yes. Mercury 2 is live via the Inception API at platform.inceptionlabs.ai and on OpenRouter. It is OpenAI-API-compatible — point your existing SDK at it and change the model name. Input is $0.25 / 1M tokens, output is $0.75 / 1M tokens, with a 128K context window.
Is DiffusionGemma free? Yes. DiffusionGemma is released under Apache 2.0. You can download weights from Hugging Face and run it locally. It needs ~18GB VRAM quantized, which fits on a consumer RTX 5090. The trade-off vs standard Gemma 4 is lower output quality — Google recommends standard Gemma 4 when you need maximum quality.
Should I replace ChatGPT in my app with Mercury 2? Not as a blanket swap. Route latency-sensitive steps (autocomplete, RAG reranking, agent-loop steps, voice) to Mercury 2, and keep frontier reasoning steps (synthesis, math, agentic coding) on GPT-5.6 or Claude Opus 5. The "cheap builder + strong judge" pattern lets you keep final-answer quality while cutting loop cost.
Is the "Selerus-1" model from the video real? We could not verify "Selerus-1" against any primary source. The closest verified model matching the video's described behavior — diffusion-based, sub-fast, commercial API, ~1000 tok/s — is Mercury 2 by Inception Labs. The video's specific numbers (1,280 wps, 157ms TTFT, 76% MMLU-Pro) don't match any published benchmark.
The bottom line
The fastest AI model in 2026 depends on what you mean by fast. For raw token generation, Mercury 2 is the verified leader at ~789–1,009 tok/s. For end-to-end latency on small requests, Command A+ and the autoregressive small models win. For reasoning quality, GPT-5.6 Sol wins. The video got the direction right — diffusion is the fastest new paradigm — and inflated the specifics. Build a routing layer, not a loyalty. That is the actual unlock, and it is available to you right now.
Discussion
0 comments