Mercury 3: Inception's Diffusion LLM Claims 1,068 Tokens/Sec and 1M Context

Inception launched Mercury 3 on October 19, 2026, and calls it "the most capable diffusion-based LLM released to date." The headline claims in the official launch post: quality on par with or better than GPT-6 Luna and Claude Haiku 5.5, speed of 1,068 tokens per second on NVIDIA GPUs, a 1M-token context window, and a list price of $0.20 per million input and $0.70 per million output tokens, half that during a launch discount.

This post separates what Inception claims from what you can check yourself, because the speed number in particular does not match what the OpenRouter listing was showing the same day. If you build search agents, voice pipelines or browser agents where every model call sits on the critical path, the details matter.

TL;DR: Mercury 3 at a glance

What actually changed from Mercury 2.5

Inception has shipped quickly. Mercury 2 arrived in February 2026 as what the company called the first reasoning diffusion model, Mercury 2.5 followed on September 8, and Mercury Voice and the Mercury Decide classifier came at the end of September. Mercury 3 is the first one where Inception leans on an argument rather than a feature: that diffusion text models scale.

The post says Mercury 3 has more than 40x the total parameters of Mercury 1 and that benchmark intelligence "has risen 3x from Mercury 1 (mini) to Mercury 3," while throughput stays about the same. Inception's reading is that "the scaling laws that drove progress in autoregressive models hold for diffusion too." That is a claim from the vendor, and the post does not publish a full benchmark table or a paper. The only named quality comparisons are against GPT-6 Luna and Claude Haiku 5.5. Some social posts name specific benchmarks such as GPQA Diamond and IFBench, but we could not find those in Inception's own text.

Speed gauge illustrating the latency-versus-quality trade-off in fast LLMs such as Mercury 3

The practical upgrade is context: 1M tokens versus 260K, with up to 131,072 completion tokens per OpenRouter's model page. For agents that stuff long documents or logs into context, that moves Mercury out of "short-turn chat" territory.

How diffusion text generation works (and why it is fast)

An autoregressive model such as GPT-6 Luna or Claude Haiku 5.5 emits one token, feeds it back in, and emits the next. Latency grows with output length. A diffusion LLM starts from a noisy or masked version of the whole answer and refines multiple positions per pass. OpenRouter's description puts it plainly: it "produces and refines tokens in parallel rather than one at a time."

Three consequences follow:

1. Throughput can be high on ordinary GPUs because each forward pass does more useful work.
2. Quality depends on the number of refinement steps, so speed and accuracy are traded through a knob, not a free lunch.
3. Streaming behaves differently. Output may appear in refining chunks rather than a smooth left-to-right stream, which matters for UI design.

For a deeper look at the research side, see our coverage of parallel text generation that claims 31x over diffusion, Apple's tri-modal masked diffusion paper and IFM's diffusion-augmented LLM speed-up.

Claimed vs measured: the speed number

This is the part worth being careful about.

• Claimed by Inception: 1,068 tokens per second on NVIDIA GPUs, and "4-8x faster" than GPT-6 Luna and Claude Haiku 5.5. The earlier Mercury 2.5 listing on OpenRouter quotes 1,107 tokens per second, so the new, much larger model is positioned as roughly equal in throughput.
• Shown on OpenRouter when we checked: a P50 throughput of 254 tokens per second and 1.91 s latency for the single Inception endpoint, with 3-day availability listed at 91.76% and a 24-hour figure near 98.7%. The model had been listed since October 16, so this was a few days of early traffic.
• Why the gap exists: the launch figure is a vendor benchmark, probably measured on dedicated hardware with a particular prompt and output length. OpenRouter's number is median real traffic through a router, mixing long prompts, cold caches and launch-day load. Neither is wrong, but they answer different questions.

None of this means the claim is false. It means you should not plan capacity from the headline. Run your own prompts, at your own output lengths, and record time to first token and end-to-end latency. Our TokenSpeed write-up covers how to benchmark agentic workloads honestly.

What the early-access partners say

Inception published four partner quotes. They are testimonials, not independent audits, but each has a concrete number worth knowing:

The TinyFish result is the most interesting: a fast model beating a much more expensive frontier model on a multi-step task, but only 50 tasks, only in TinyFish's harness, and "completed 50%" still means half failed. Treat it as a hint to run your own agent evals.

Staircase of model versions with the newest step highlighted, representing the Mercury 3 release

Price: where Mercury 3 sits

At $0.20 input and $0.70 output per million tokens, Mercury 3 is priced as a small-model API. Launch pricing of $0.10 and $0.35 is half that, and OpenRouter shows cache reads at $0.01 per million. Compare with the small-model tier we benchmarked in Haiku 5.5, GPT-6 Luna, DeepSeek V4.1 Flash and others, and see the Claude Haiku 5.5 launch and GPT-6 Sol and Luna pricing posts for rival rates. Remember that a promo price is temporary: budget on $0.20/$0.70.

Cost per task is the number that matters. A fast model that needs more retries or more reasoning tokens can lose its price edge, and Inception has not published a cost-per-task comparison.

How to try Mercury 3

Because it is OpenAI API compatible, switching is a base-URL and model-name change. On OpenRouter the slug is inception/mercury-3.

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "inception/mercury-3",
    "messages": [{"role": "user", "content": "Summarize this log in five bullets."}]
  }'

A sensible evaluation plan:

1. Pick 30 to 50 real prompts from your own product, including long-context ones.
2. Run them against Mercury 3, your current small model and one frontier model.
3. Record time to first token, total time, pass rate and total cost.
4. Re-run after the launch discount ends.

Inception offers 100 million free tokens for new API keys, so this costs nothing to start. The model is also reachable through Baseten and Vercel, and Inception lists dedicated capacity, autoscaling, compliance controls and configurable data retention for enterprises.

The rest of the portfolio

Mercury 3 is the flagship in what Inception calls a real-time product line. Mercury Voice targets time to first answer token for voice agents and is reported to power Audivi AI, Altur and OpenCall. Mercury Decide is a classification model that returns choices with calibrated probabilities; Inception says it beats Jev on JevBench and LegalBench. For background on that category, read what decision models are and our Jev browser-use coverage.

Limits and open questions

• No open weights and no paper for Mercury 3. You cannot inspect architecture or reproduce the numbers.
• Sparse benchmark disclosure. Quality is described as "on par or better" on a "range of benchmarks" without a published table in the launch post.
• Latency versus throughput. High tokens per second does not guarantee a low time to first token; Inception itself created Mercury Voice to minimize that metric.
• Availability. OpenRouter showed a single provider and a 3-day availability under 92% at the time we looked; that will likely improve, but check before putting it in a critical path.
• Fit. A fast, cheap model is best for latency-bound subtasks such as subagents, routing, search and tutoring. Hard reasoning and long-horizon coding may still favor a frontier model.

What this means for what you build or pay

If your product waits on the model in a loop (browser agents, search, voice), cutting each step from seconds to under one second compounds into a very different user experience, and Mercury 3 is now a credible candidate to put in that slot. If you mostly run single long answers, the gain is smaller. Either way, treat 1,068 tokens per second as a ceiling, not a plan, and let your own eval decide.

Related reading

• Small models compared: Haiku 5.5, GPT-6 Luna, DeepSeek V4.1 Flash and more
• Claude Haiku 5.5 launch, pricing and benchmarks
• GPT-6 Sol and Luna launch and pricing
• Parallel text generation, 31x faster than diffusion
• What are decision models?
• TokenSpeed inference engine for agentic workloads

Specifications and prices are accurate as of October 19, 2026 and may change; check Inception's pricing page and OpenRouter for current values.