Diffusion Models Can Scale: Inception's Mercury 3 Outruns GPT-6 Luna and Haiku 5.5 at 1,068 tok/s

On October 19, Inception Labs announced Mercury 3 via Business Wire — "the most capable diffusion LLM ever released." Three numbers carry the whole story: 1,068 tokens per second of inference speed, a 1-million-token context window, and benchmark quality matching or beating GPT-6 Luna and Claude Haiku 5.5.

If you haven't heard of Inception Labs, meet the company: co-founded by Stanford professor Stefano Ermon, it's "the company behind the first commercial diffusion large language models." The investor roster is absurdly stacked — Menlo Ventures, Mayfield, M12 (Microsoft's VC arm), Snowflake Ventures, Databricks Ventures, plus individuals Andrew Ng, Andrej Karpathy, and Eric Schmidt. When Ng and Karpathy both bet on the same thing, it's not a side project.

What makes Mercury 3 matter isn't "yet another model" — it's that it answers the question the AI community has argued about for over a year: can diffusion models actually scale?

Diffusion vs. autoregressive: a war of parallel against serial

Thirty seconds of background. Nearly every LLM today (GPT, Claude, Gemini, DeepSeek) is autoregressive: it generates one token at a time, like a typewriter hammering left to right. The upside is stable quality; the downside is that even the smartest model has a typing-speed ceiling. Token N+1 can't start until token N is done.

Diffusion takes another road: start from a "noisy draft" and denoise/refine in parallel, generating many tokens at once. The Business Wire release puts it plainly: "Unlike traditional autoregressive models, which generate text sequentially, one token at a time, diffusion models can generate multiple tokens in parallel, offering a fundamentally different path to faster inference."

Diffusion conquered images (Stable Diffusion, DALL-E) long ago, but text had a sticking point: academic diffusion text models were long confined to simple tasks like code autocomplete. In June 2025 Inception shipped Mercury 1, the first proof that diffusion LLMs could serve real commercial traffic. Mercury 2 added reasoning to diffusion. Mercury 2.5 added tunable reasoning and a 260K context window. Mercury 3 is the final exam on "can diffusion scale" — more than 40x the size of Mercury 1, with speed fully intact at 1,000+ tok/s.

Ermon's quote in the announcement deserves a slow read: "Since we launched Mercury 1, the question we've heard most is whether diffusion can scale. Mercury 3 is over 40 times larger, significantly more capable, and still runs at over 1,000 tokens per second. We're showing that the limits to scaling diffusion models are compute and data, not fundamental algorithmic barriers."

Note the subtext of that last sentence: the scaling laws that powered autoregressive progress hold for diffusion too. If that's true, the industry's three-year all-in bet on "autoregressive scaling" isn't the only road — a second road just got empirically paved.

The hard numbers: what 1,068 tok/s means

What does 1,068 tokens per second mean? Per the company, Mercury 3 runs 4–8x faster than GPT-6 Luna and Claude Haiku 5.5 at "on par or better" benchmark quality. Pricing: $0.20/1M input and $0.70/1M output list, 50% off at launch ($0.10/$0.35), cached tokens another 90% off. Context jumps from 260K (Mercury 2.5) straight to 1 million.

More important than the numbers is Inception's argument about speed. The release has a passage written for agent developers: "In agentic systems, where a model makes repeated calls to finish one task, delays add up at every step." That nails a hidden pain point of 2026 agent development: latency compounds. An agent task that calls the model 30 times at 2 extra seconds per call costs you a full minute; users tolerate one 2-second wait, not thirty. Mercury 3's 1,000+ tok/s is aimed squarely at making every step feel instant.

Early customers are already running production traffic in four scenarios: browser use agents, interactive education, real-time search agents, and customer support. Michael Tong, co-founder/CTO of General Learning (aka RevisionDojo), gave a refreshingly concrete quote: "Mercury 3 allowed us to give every student instant feedback without giving up reasoning. Hints, marked answers and definitions now come back in about a second, with quality as good as or better than the models we ran before." "About a second" — that's what 1,000+ tok/s feels like in a product.

A brief history of diffusion: three years from academic toy to 40x scale

To feel Mercury 3's weight, you need to know how hard this road was. Before 2024, diffusion LMs were essentially academic toys: they ran on controlled datasets but fell apart on open-domain generation — poor coherence, long text going off the rails. The turning point was Mercury 1 in June 2025: Inception made it the first diffusion LLM you could actually buy, proving it could serve real commercial traffic. That day, diffusion went from paper to product.

Mercury 2 attacked the "dumb" problem: adding reasoning to diffusion. The knock on diffusion had been "fast but shallow" — fine for short-burst tasks like code completion, hopeless at multi-step thinking. Mercury 2 proved diffusion architectures could do chain-of-thought-style reasoning. Mercury 2.5 added tunable reasoning and a 260K window, handing developers the "fast vs. deep" dial.

Mercury 3's exam question was "big": 40x the size of Mercury 1, speed intact, quality up. Why is that hard in engineering terms? Because parallel generation has an intrinsic tension — more parallelism means more compute per step, and bigger models mean slower steps. Hitting "40x scale at 1,000+ tok/s" means Inception found a new sweet spot in the parallelism-vs-size tradeoff. The release discloses no technical details (trade secrets), but Ermon's message is clear: the bottleneck is compute and data, not algorithms — "give it enough chips and enough data, and diffusion can go bigger." He added they've already started training the next one. No false modesty there.

Followers on this road are multiplying. Academic diffusion text models like LLaDA and Dream kept climbing benchmarks through 2025–2026, proving "diffusion for text" isn't Inception's private magic. But Inception's edge is the commercial loop: Mercury 1 through 3, each generation validated in real production traffic, each fixing one concrete weakness (commercial → reasoning → tunable → scale). That "one hurdle per generation" cadence is something academia can't deliver.

Skepticism, served cold: don't pop the champagne yet

That said, a responsible report should flag the question marks in Mercury 3's announcement.

First, the benchmarks are "company-reported." "Outperforms GPT-6 Luna and Claude Haiku 5.5 across a range of standard benchmarks" — measured by Inception, said by Inception. Selective disclosure in vendor benchmarks is a tale as old as benchmarks: pick the favorable ones, skip the rest. Mercury 3's real standing waits on independent evals from Artificial Analysis or LMArena. Until then, put an asterisk after "on par or better."

Second, ecosystem maturity. The autoregressive world has three years of toolchain accumulation: vLLM, llama.cpp, Ollama, quantization recipes — all turnkey. Diffusion inference is a different stack: parallel-denoise scheduling and KV-cache reuse work differently. Mercury 3 is OpenAI API compatible (painless on the calling side), but teams wanting to self-host will find diffusion's local-inference ecosystem still early. Inception is pushing its own API plus OpenRouter/Baseten/Vercel; private deployment options are thinner than the autoregressive camp's.

Third, 1,068 tok/s of "feel" isn't "useful." Fast token emission doesn't mean fast task completion. End-to-end agent latency = model inference + tool calls + network round trips, and inference is only one term. If your agent's bottleneck is a slow tool API, Mercury 3's speed advantage dilutes. Profile your agent loop and find the real bottleneck before ordering — that's 2026 agent-development fundamentals.

Fairly said, none of these three cold showers extinguish Mercury 3's core value: it proves with a product that "the second road" works. Even with watered-down benchmarks and an early ecosystem, "40x scale, speed intact" alone is enough to make every autoregressive team re-evaluate its roadmap. Historically, every moment a paradigm gets un-falsified is where innovation starts.

Through a coding agent's eyes: what parallel generation means

For VibeFix's core readers — people who write code with AI — diffusion has a special significance. Think about your daily workflow: you ask an agent to write a function, it types from line one to the last; you want to change something in the middle, it rewrites everything after. That's autoregression's fate: strictly left-to-right.

Diffusion's "parallel refinement" theoretically breaks that fate: it can edit locally. Imagine a future coding agent: after generating a first draft, you point at line 37 and say "this logic is inverted," and the model denoises only lines 30–45, leaving the rest untouched — fast, precise, no new bugs introduced. That's the "editability" dividend. Mercury 3 doesn't expose such an API yet (the release doesn't mention it), but architecturally it's the natural move. Once exposed, "refactoring" — the highest-frequency coding scenario — gets reshaped: changing code stops being "tear down and rebuild" and becomes "precision surgery."

Further out, diffusion's parallelism could change sampling logic itself. An autoregressive model that wants to try N approaches must generate N full times; a diffusion model can explore multiple candidates in parallel within one denoising run (a natural beam-search-like shape). The release's line — "have time to try more approaches before answering" — points exactly there: speed buys not "one answer faster" but "more answers compared in the same time." For coding, that most trial-dense of crafts, that's worth more than the raw speed number.

What it means for vibe developers: a triple shock to latency, cost, and architecture

First, the real-time agent barrier just got smashed. Voice agents, pair-programming agents, live translation — latency-critical scenarios that used to force a choice between "small model (fast but dumb)" and "big model (smart but slow)." Mercury 3's pitch is having both: flagship-grade intelligence at small-model speed. For indie developers, previously unbuildable real-time interactive products now have an off-the-shelf base. And it's OpenAI API compatible, live on OpenRouter, Baseten, and Vercel — a drop-in swap, no rewrite needed to try it.

Second, the economics of the agent loop changed. MiniMax's M3.1 Flash (our N1 this cycle) attacks agent cost from the price side; Mercury 3 attacks from the speed side. If an agent task calls the model 50 times, Mercury 3's 4–8x speed edge directly becomes "4–8x more approaches tried in the same time." In the release's words: "Agents finish sooner and have time to try more approaches before answering." Speed converts into "thinking budget": run fast, and the agent dares more self-correction rounds, and success rates follow. That's an inversion of "slow and steady": fast can also be careful.

Third, the unreleased "editability" dividend of the diffusion road. That's my own read: diffusion's "refine from a noisy draft in parallel" is natively suited to post-generation editing — draft once, then surgically revise a few sections without regenerating from scratch. An autoregressive model that changes one word must recompute everything after; a diffusion model could in principle refine just the local region. Inception hasn't announced this, but it's an intrinsic architectural advantage. If Inception (or followers) ever open a "local re-refinement" API, the "change outweighs writing" scenarios — writing, code refactoring — get reshaped. Consider this a planted flag.

October 19: AI's "speed and cost day"

Put Mercury 3 next to MiniMax's M3.1 Flash, launched the same day, and October 19 becomes 2026's "speed and cost day" for AI: MiniMax redefined agent-task cost with $0.15/$0.60 pricing and 200+ tok/s; Inception redefined the inference speed ceiling with 1,068 tok/s at half price. Two companies, one Chinese, one American, same day, same theme: make agents run faster and cheaper.

That's not coincidence — it's the main plot shift of H2 2026 model competition: the flagship "intelligence race" has plateaued (everyone's clustered around 90 points), and the contest moved down to the "efficiency race" — whoever lets agents run at lower latency and lower cost wins developers' production traffic. Mercury 3's "40x scale, speed intact" and M3.1 Flash's "70% cheaper, 3x faster" are the same story: efficiency is becoming the new intelligence.

By the way, Mercury 3's launch timing is worth noting: the same day as MiniMax's M3.1 Flash. One talks "cost," the other "speed" — together they turned October 19 into agent infrastructure's "Singles' Day." Less coincidence than consensus: in H2 2026, the winning move isn't "who's smarter," it's "who makes agents run smoother."

Industry reaction: a double vote from HN and investors

On launch day, Mercury 3's HN thread hit 200 points and 78 comments within 4 hours — in the "model-launch fatigue" of late 2026, that heat means developers genuinely care about "the second road." The top-voted take was classic: "autoregressive optimization is tapped out (speculative decoding, KV-cache squeezing, everything) — diffusion is one of the few architectures that can still deliver order-of-magnitude change." The cold water was there too: "wait for independent evals; vendor benchmarks are vendor benchmarks." Both are right, and that's the maturity of the 2026 developer community: excited about new architectures, but letting the bullets fly a while.

Investors voted differently. Inception's shareholder list — Menlo, Mayfield, M12, Snowflake, Databricks — is pure "infrastructure VC," plus three godfather-tier individuals in Ng, Karpathy, and Schmidt. The signal: the market isn't betting on "a model" but on "the diffusion inference stack" itself. Snowflake and Databricks joining is especially telling — these data-infrastructure giants want "faster, cheaper model inference" for their data-cloud customers. Mercury 3's 1,068 tok/s is a direct cost-and-efficiency tool for them.

Things to watch next: first, independent evals (Artificial Analysis, LMArena) — when Mercury 3 lands there and whether the numbers reproduce; second, the autoregressive camp's response — will OpenAI, Anthropic, or Google ship diffusion too, or absorb diffusion's strengths into hybrid architectures; third, Ermon's "next model" — if diffusion scaling laws truly hold, the next generation could challenge the very definition of flagship "intelligence"; fourth, open-weights followers — once high-quality open diffusion weights exist, the era of local real-time agents truly begins.

Back to the opening question: can diffusion scale? Mercury 3's answer is "yes — at least to 40x." The value of that answer isn't how strong Mercury 3 itself is; it's that it turned the AI industry from a one-lane road into a two-lane highway. On one lane everyone races to run faster; on two lanes someone starts asking "should we switch lanes." And history keeps proving: the dividends of paradigm competition always dwarf the dividends of paradigm involution. For vibe developers, the best strategy isn't "picking a side" — it's "try both." Your agent loop should run on autoregressive and diffusion.

One practical note: if you want to try Mercury 3 right now, the easiest path is OpenRouter — it launched there day one alongside Baseten and Vercel, OpenAI API compatible, so your existing agent code runs with a base_url and model-name change. Take one genuinely latency-sensitive task (live support, voice interaction) and A/B it: same task on Mercury 3 vs. your current workhorse model, comparing end-to-end time, success rate, and bill. Data beats vibes; run it and you'll know whether the diffusion road deserves your bet.

Transparency note

Core facts (Mercury 3 launch, 1,068 tok/s, 1M context, 40x Mercury 1, 4–8x speed, $0.20/$0.70 list pricing with 50% launch discount, OpenAI API compatibility, OpenRouter/Baseten/Vercel availability, four early-customer scenarios, investor list) are all from Inception's official Business Wire release, read in full (release ID 20261019090400; no standalone date stamp on the page — the October 19 date comes from the release ID plus consistent Unite.AI/RuntimeWire/DailyAIBrief reporting). Benchmark comparisons (beating GPT-6 Luna/Claude Haiku 5.5) are company claims, not independently verified. The Ermon and Michael Tong quotes are verbatim from the release. "Local re-refinement APIs for diffusion models" is the author's architecture-based inference, not an official statement, as flagged in the text.