Inception's Mercury 2.5 Hits 1,107 Tokens per Second, Beating Autoregressive Models

Inception just dropped Mercury 2.5, a diffusion language model the company says is the largest of its kind ever trained. It pairs frontier-tier quality with speeds that autoregressive models cannot match on the same hardware, and Inception is positioning it squarely for production pipelines where latency compounds across many model calls.

Traditional LLMs generate one token at a time. Diffusion LLMs (dLLMs) instead iteratively denoise many tokens in parallel, borrowing the same basic mechanism as image diffusion models. That parallelism is what pushes Mercury past 1,000 tokens per second on commodity GPUs, a figure no autoregressive model at this price point comes close to.

The numbers that matter

Here is what Inception is releasing:

• 40% intelligence gain over Mercury 2, comparable to cost-optimized frontier models including GPT-5.6 Luna (Low), Gemini 3.5 Flash-Lite, and Claude Haiku 4.5
• 1,107 tokens per second on widely available NVIDIA GPUs
• 260K token context window
• $0.20 per million input tokens and $0.75 per million output tokens, with an 80% launch discount dropping those to $0.04 input / $0.15 output
• Tunable reasoning, parallel tool calls, and schema-aligned JSON output

Benchmarks span agentic tool use (Tau3Bench Telecom), scientific reasoning (GPQA Diamond, SciCode), instruction following (IFBench), long-context recall (AA-LCR), and terminal-based coding (TerminalBench). Positioning against Haiku 4.5 and Flash-Lite puts Mercury 2.5 in the cheap-and-fast tier rather than against flagship reasoning models, which is the honest framing given the architecture's priorities.

Where the speed actually pays off

Search and RAG pipelines are a natural fit. A single user query can trigger dozens of model calls to plan the search, rewrite queries, rerank results, structure facts, summarize sources, and verify the answer. Mercury keeps those calls fast enough to complete within a single interaction. Voice agents benefit even more directly: OpenCall, which builds AI phone agents, reported that switching to Mercury dropped P99 response time from several minutes to one second, with P50 falling from 0.4 seconds to under 0.2.

The coding agent case makes the cost argument most concretely. Augment Code runs Mercury for context compaction, model routing, and MCP tool search. Moving compaction to Mercury cut latency 82%, from roughly 150 seconds to 27 seconds, and reduced cost by 90% with no quality regression. The underlying logic generalizes: use a capable but slower model for the hard reasoning step, and a fast cheap model for the supporting calls surrounding it.

Two adjacent products also previewed

Mercury Voice targets voice agents with time-to-first-token under 170 milliseconds, optimized for the tightest latency budgets. Mercury Router uses a dLLM to classify incoming prompts and route them across open and closed models, balancing quality, speed, and cost. Because the router itself runs on Mercury's fast inference, the routing decision adds negligible overhead relative to the inference call it dispatches.

How to get access

Mercury 2.5 is available through the Inception API, OpenRouter, and Baseten. The API is OpenAI-compatible, so swapping it in is close to a one-line change:

import requests
response = requests.post(
    'https://api.inceptionlabs.ai/v1/chat/completions',
    headers={'Authorization': 'Bearer INCEPTION_API_KEY'},
    json={
        'model': 'mercury-2.5',
        'messages': [{'role': 'user', 'content': 'Hello'}],
        'max_tokens': 1000
    }
)

New accounts get 10 million free tokens per API key, and the models page lists a 100 million token free trial. Cached input drops to $0.02 per million tokens, which matters for agent workloads that reuse system prompts heavily.

Who should benchmark this

Mercury 2.5 targets the Haiku / Flash-Lite tier, and Inception is explicit about that. Hard single-shot reasoning tasks still belong to GPT-5 or Claude Opus. Mercury earns its place in pipelines where many model calls stack per user action and latency compounds: search rerankers, voice agents, tool-use loops, context compaction, query rewriting, and routing. If a current workload uses a small autoregressive model and is latency-bound rather than intelligence-bound, Mercury 2.5 is worth running against real production traces.

Diffusion architectures for text have moved from research curiosity to systems handling live phone calls and production coding agents. That shift is worth tracking regardless of whether Mercury ends up in your stack.