Mercury 3: Diffusion at scale

TL;DR Highlight

Scaling diffusion LLM 40x gives Mercury 3: 4–8x faster than speed-tier models, similar quality

Who Should Read

A backend developer running latency-sensitive LLM services like voice/chat support or browser agents who wants a faster, cheaper model

Core Mechanics

Mercury 3 is a diffusion-based LLM
- Inception calls it the most capable diffusion LLM released to date.
- It claims to beat GPT-6 Luna and Claude Haiku 5.5 on a range of benchmarks while running 4–8x faster.
Speed is 1,068 tokens/sec on NVIDIA GPUs
- The claim is 1,000+ tokens per second.
- Context is 1M tokens, up from 260K for Mercury 2.5.
40x bigger than Mercury 1 but just as fast
- Total parameters are scaled more than 40x.
- Intelligence across standard benchmarks is said to be up 3x from Mercury 1 (mini).
- The company says autoregressive scaling laws hold for diffusion too.
Pricing is $0.20 input and $0.70 output per 1M tokens
- Launch pricing is 50% off: $0.10 input and $0.35 output.
- Cached tokens get 90% off the input price.

Community Reactions

Hands-on experience: fast and capable
- One user built a Swift UI OCR and translation app in 8–9 steps, fixing only a coordinate bug.
- It took about 45 minutes and 26M tokens (1.3M uncached) at around 160 TPS.
Real-world speed was below the advertised number
- One user saw 300–400 tps after a slow start.
- Another said deepseek v4.1 flash on OpenRouter beat Mercury 3 on latency and intelligence, and that TTFT was slow.
Price impressed some, while discount expiry worried others
- A commenter noted Haiku 5.5 gets 5x pricier past 100k context while Mercury 3 goes to 1M at one price.
- Another asked whether it will still be useful after the discount ends.
Doubts about comparisons and wish list
- One commenter said comparison with Luna isn't fair without matching training data and post-training.
- Another asked whether non-linear token generation makes reasoning harder to interpret.
- Some wished for multimodal support and a coding subscription plan.

How to Apply

Swap base_url and compare latency
- Today, point your OpenAI-compatible client at Mercury 3 with the new model name.
- Run the same 20 prompts on your current fast model and measure TTFT and total time.
- The 100M free tokens are enough for this.
Route only latency-sensitive steps to Mercury
- Pick steps users wait on, like voice/chat replies, hints, or post-search summaries.
- Keep hard reasoning steps on your current model and compare per step.
Measure quality and cost in your agent harness
- Swap only the model in a browser or log-analysis agent.
- Record success rate, step count and token volume.
Recompute cost at list price
- Multiply monthly input/output tokens by $0.20/$0.70 per 1M.
- Apply the 90% cache discount to cacheable prompts.

Try It

copy & run

# Run in terminal (OpenAI-compatible latency check; base_url and model name aren't in the source, fill them in)

pip install openai

import os, time
from openai import OpenAI

BASE_URL = "{{base_url from Inception API docs}}"
MODEL = "{{Mercury 3 model name from docs}}"
client = OpenAI(base_url=BASE_URL, api_key=os.environ["INCEPTION_API_KEY"])

prompt = "{{your current prompt}}"
start = time.time()
first = None
for chunk in client.chat.completions.create(model=MODEL, messages=[{"role": "user", "content": prompt}], stream=True):
    if first is None and chunk.choices and chunk.choices[0].delta.content:
        first = time.time() - start
print("TTFT:", first, "total:", time.time() - start)

Next: run the same script against your current model and compare medians over 20 prompts.

Terminology

diffusion LLMInstead of writing text token by token, it refines a rough draft over several passes until the text is complete.

autoregressive modelThe usual LLM style that predicts the next token from the previous ones, like typing one character at a time.

TTFT/TTFATTime until the first token (or first answer token) appears. For voice, this matters more than total time.

scaling lawsThe empirical rule that making models bigger improves performance predictably.