Mercury 2 Hands-On Review: The Fastest Inference LLM Powered by Diffusion Models — A Complete Game Generated in 18 Seconds

Inception Labs recently released Mercury 2, a large language model built on diffusion model architecture, claiming to be the world's fastest inference model. Unlike autoregressive models like GPT and Claude that generate text word by word, Mercury 2 can generate text in parallel and iteratively refine its output, achieving over 1,000 tokens per second in real-world testing. This isn't just a speed improvement — it represents an entirely new paradigm for text generation.

Diffusion Models vs. Autoregressive Models: A Paradigm-Level Difference

The models we're familiar with — GPT, Claude, Gemini — all use autoregressive (AR) architecture. Their core mechanism is sequential token generation — predicting one token at a time, then using the generated content to predict the next. While this approach is mature and reliable, it has an inherent speed bottleneck: generating 1,000 tokens requires 1,000 forward passes.

The fundamental limitation of autoregressive models lies in their serial computation nature. Each forward pass requires feeding the entire context (including all previously generated tokens) back into the model to predict the next token. Even with KV Cache (key-value caching) to reuse historical computation results, the sequential dependency remains — because generating token N depends on the result of token N-1, these operations cannot be parallelized. This is why mainstream models today often exhibit noticeable Time to First Token (TTFT) latency and overall generation delays in real-time conversation scenarios.

Mercury 2's diffusion model approach works completely differently. It operates more like an editor: first generating a complete draft of the entire response in parallel, then iteratively refining it through multiple rounds of polishing. This means it can process multiple tokens simultaneously in a single step, fundamentally breaking through the constraints of sequential generation.

Diffusion models first gained prominence in image generation — Stable Diffusion, DALL-E 2, and similar models generate high-quality images through an iterative "noise-denoise" process. Migrating this paradigm to text presents a fundamental challenge: text consists of discrete token sequences rather than continuous pixel values, making it impossible to directly apply continuous-space diffusion processes. Early discrete diffusion language models (such as MDLM and SEDD) addressed this by defining diffusion processes in token embedding space or mask space. The Mercury series represents a commercial breakthrough in this research direction — a significant milestone in bringing discrete diffusion language models from academic prototypes to production-ready systems.

Looking at actual benchmarks, Mercury 2's generation speed reaches 5x that of speed-optimized models like Claude Haiku 4.5 and GPT-5 Mini, while scoring 91.1 on the AIME benchmark, demonstrating that the speed gains don't come at the cost of reasoning quality.

AIME (American Invitational Mathematics Examination) is an important competition in the U.S. high school mathematics contest system, featuring challenging problems in number theory, algebra, combinatorics, and geometry. In AI evaluation, AIME has become one of the gold standards for measuring mathematical reasoning ability, with a maximum score of 150 (15 questions × 10 points). Mercury 2's score of 91.1 means its mathematical reasoning capability has reached top-tier levels, placing it in the same competitive bracket as OpenAI's o-series and DeepSeek^Ad-R1 — models specifically focused on reasoning. This result is particularly significant for diffusion models, as it dispels concerns that "parallel generation would compromise logical coherence."

Practical Testing: Comprehensive Code Generation Comparison

Tetris Game Generation

In a particularly challenging test, the author asked each model to generate a Tetris game where "blocks float upward instead of falling down." The results varied significantly:

• Gemini 3 Flash: Took approximately 1 minute 8 seconds; the generated game couldn't even run
• Claude Haiku 4.5: Took 1 minute 24 seconds; physics mechanics implemented correctly
• Mercury 2: Only 18 seconds; generated a fully playable game that correctly followed the upward-floating block design

With reasoning intensity turned down, Mercury 2 can complete code generation in just a few seconds. With diffusion mode enabled, you can visually observe the parallel generation process — the code appears almost instantly after the instruction is issued.

MacOS-Style Web Operating System

In a frontend development capability test, the author asked Mercury 2 in high-reasoning mode to build a MacOS-style web operating system with SVG icons. Tasks like this typically take several minutes, but Mercury 2 scaffolded the basic frontend framework in just 12 seconds, including a complete component structure and SVG icon code. While the full logic for each application wasn't completely written, as a rapid prototyping tool, the performance was quite impressive.

Physics Simulation: A Galaxy with 500 Stars

Even more impressive was a physics simulation test: generating a galaxy with 500 stars interacting through gravity, with support for clicking to add supermassive black holes. Mercury 2 not only generated runnable code but also accurately simulated the gravitational effects of multiple black holes on surrounding stars, demonstrating excellent multi-step coding and algorithmic reasoning capabilities.

Structured Reasoning and Rule-Following Ability

Speed is just one dimension of Mercury 2 — its structured reasoning capabilities are equally noteworthy.

Customer Support Scenario Test

The author configured the model as a technical support agent, requiring it to explain a smart thermostat's WiFi connection issue at a fifth-grade reading level. Mercury 2 delivered a ten-step solution in extremely short time while meeting multiple strict requirements: controlled reading difficulty, avoidance of jargon, and proper text formatting.

Rule-Based Customer Service Agent

In a more complex customer service scenario, the model needed to enforce strict return/exchange policies (such as a 45-day time limit) while resisting user pressure and maintaining role consistency. Mercury 2 correctly understood the time constraints, guided users through appropriate questioning, and steadily followed structured rules without any role deviation or logical errors.

This also highlights the natural advantage of diffusion models in avoiding cumulative errors. Autoregressive models suffer from an inherent issue called "exposure bias": during training, the model sees real historical tokens, but during inference, it relies on its own generated tokens as input. Once an incorrect token is generated at any position, that error is inherited and amplified by all subsequent generation steps, creating cumulative drift. Diffusion models fundamentally avoid this by generating globally in parallel — they can "go back and correct" previously generated content in each iteration, similar to a human's draft-and-revise writing process, rather than the autoregressive model's "write once, no turning back" approach. This explains why Mercury 2 performs reliably in customer service scenarios requiring precise adherence to multiple rules.

Long-Range Planning: Story Writing with Incrementally Increasing Sentence Length

A particularly interesting test examined the model's global planning ability: starting with a two-word sentence and progressively increasing sentence length up to 20 words, while maintaining narrative coherence. This is extremely challenging for autoregressive models because it requires continuously tracking and planning sentence length throughout the generation process.