Diffusion LLM: Mercury 2.5 and model routing

On 2026-09-08 Inception Labs launched Mercury 2.5, the largest diffusion LLM trained to date, with 40% more intelligence than Mercury 2, 1,107 tokens per second on NVIDIA GPUs, and a price of US$0.20 per million input tokens and US$0.75 per million output tokens, per the official announcement: Introducing Mercury 2.5. The date follows the announcement footer; the page was consulted on 2026-09-15. The implication that matters: a diffusion architecture that wins on tokens per second per dollar changes which model each type of traffic should receive.

What Inception Labs announced with Mercury 2.5

Mercury 2.5 is a diffusion model, not an autoregressive transformer, and it is the largest variant trained in that class. Instead of emitting one token at a time, left to right, a diffusion LLM generates a whole block of masked tokens in parallel and refines all positions across a fixed number of denoising steps. The throughput and latency gain comes from that parallel generation per step, not from a generic iterative process. Inception Labs positions the result as comparable, in intelligence, to frontier models optimized for cost: GPT-5.6 Luna (Low), Gemini 3.5 Flash-Lite and Claude Haiku 4.5. Throughput is what separates the line: 1,107 tokens per second on NVIDIA GPUs.

The architecture is the starting point. Diffusion and autoregressive transformer produce text through different paths, and the speed difference comes from there. The figure of 1,107 tokens per second is measured on NVIDIA GPUs, per request and in single stream. It is worth qualifying: autoregressive models served with continuous batching and accelerated hardware, in the class of Cerebras and Groq, already reach four digits of tokens per second per request. Mercury's differentiation is not raw speed alone, it is the economics of serving a diffusion architecture. The context window reaches 260 thousand tokens.

The launch price is US$0.20 per million input tokens and US$0.75 per million output tokens. During the launch promotion, Inception Labs charges US$0.04 and US$0.15. Two products were announced in preview on the same day: Mercury Voice and Mercury Router. The Router places a model vendor inside the layer that decides which model serves each call, something that until now was the territory of independent gateways or of decisions made by the application itself.

Customer proof points came along. Augment Code reported an 82% reduction in compaction latency, from 150 seconds to 27, and a 90% cut in the cost of that step. OpenCall took P99 from minutes to about one second. These are vendor-reported customer cases, so read them as primary-source reporting, not as an independent audit.

Why cost per task changes the routing decision

The metric that decides an inference budget is not price per million tokens, it is cost per completed task. If the diffusion architecture delivers useful answers with more throughput per GPU, each minute of GPU produces more work, and the cost per request can fall even with a nominal price similar to a competitor's. Except cost per task is not price per token times speed: diffusion inference spends GPU on iterative denoising steps, and the result depends on batch size, step count and token efficiency, none of which the source disclosed. The figure of 1,107 tokens per second is measured by the vendor, in an unspecified serving configuration, so the real cost-per-task math has to be measured on the buyer's own load.

Consider the compaction case. Augment Code reported that the same step fell from 150 seconds to 27, with 90% less cost. An engineer who runs compaction dozens of times a day feels the difference in minutes, not in a fraction of a cent.

That is the point.

The axis of the dispute left price per token and moved to tokens per second per dollar. Anyone routing only by list cost is measuring the wrong variable on interactive loads.

There is an honest limit to this reading. The company did not publish, in the announcement, an independent task-by-task quality comparison against the frontier models it names itself. What exists is the claim of intelligence parity and a handful of customer cases. Inception Labs is the source of those numbers, and the correct reading is to treat parity as a vendor claim until third-party comparisons appear. None of this takes away the value of the launch: the price and the speed already change the arithmetic even with parity still open.

Where a speed-first model enters the routing policy

A fast and cheap model does not replace the frontier in everything. It replaces the frontier in high-volume, low-ambiguity traffic, where the task has a predictable shape and the cost of error is low. That is where volume turns into bill inflation and where latency shows up for the end user.

The honest counterpoint is worth stating: a cheap and fast tier for production is not new, and it already exists in the cost-optimized models that Inception Labs itself names. Anyone routing by cost and latency already sends traffic to that class. What Mercury 2.5 brings that is new is not the concept of a non-frontier tier in production, it is the diffusion architecture and the price and speed point where it arrives.

The list of candidates is predictable: classification, field extraction, snippet summarization, short rewriting, template filling and first-line triage. It is routine.

Deep-reasoning traffic stays on the frontier. Multi-hop analysis, code with long dependencies, regulatory decisions, everything that requires the last mile of quality justifies paying more per token and waiting longer for a response. The intelligence frontier measured by independent indices shows where it stands today, without asserting Mercury 2.5's specific position in that index, and a good routing policy does not pick a winner: it writes the rule for which traffic goes to which class.

The Mercury Router announced by Inception Labs is the market signal here. When the entity training the model also launches the layer that decides which model serves each call, routing stops being an implementation detail and becomes a control plane. It also changes the power relationship: the vendor starts wanting to control the routing decision that used to sit with the buyer.

• High volume, low ambiguity, error tolerance: a natural candidate for the diffusion model, for speed and cost per task.
• Deep reasoning, few calls, high cost of error: stays on the frontier, accepting higher price and latency.
• Interactive with a P99 time limit: the fast model is what saves the experience, and the OpenCall figure shows the size of the gain.

What changes in practice

The axis moved. The table below compares how the routing decision was made before the diffusion class entered production and how it looks after, with the cost-per-completed-task variable in the math and price per token demoted to one of the factors. The dynamic routing and vendor-in-the-routing-layer rows are trends to watch, not production capability: the Mercury Router was announced in preview only.

The table sums up the shift. Price per token still exists and still matters, but it stopped being the sole criterion. Anyone buying inference now needs three numbers per candidate: cost per million tokens, tokens per second and end-to-end latency at P99.

How to evaluate without being fooled by the benchmark

The classic mistake is choosing by the price table and only discovering the real bill when it shows up on the GPU invoice, in the monthly budget overrun or in the time limit the user tolerates. The correct path is to measure per task, on your own traffic, with your application's hit rate.

1. Define the task and the acceptance criterion before comparing models. "It responded" is not a criterion, "it passed the extraction test in 96% of cases" is.
2. Measure cost per completed task, not price per token. Divide total cost by the number of tasks that passed the criterion. The context cost as a decision vector enters this math, not just the list price.
3. Measure end-to-end latency, and look at P99, not the average. The average hides exactly the tail that breaks the interactive experience.
4. Run the same prompt in parallel across the candidates and compare the three numbers side by side. The model ranking serves to pick the finalists, never to close the decision.
5. Reassess the route when price, speed or a new model changes. They change every week.

The rule holds for anyone routing more than a few hundred million tokens per month. Below that, the gain from optimizing the route usually does not pay for the work of measuring and maintaining the policy. Above it, it pays back in the first quarter of use.

FAQ

Mercury 2.5 is a diffusion LLM, and what does that change in practice? Diffusion generates a whole block of masked tokens in parallel and refines all positions in denoising steps, instead of emitting token by token left to right as the autoregressive transformer does. In practice, the gain shows up in throughput per request: 1,107 tokens per second, according to Inception Labs, which reduces cost per task and latency on high-volume interactive loads, with the caveat that the measurement is the vendor's, in an unspecified configuration.

Does Mercury 2.5 replace frontier models like GPT-5.6 Luna (Low) or Claude Haiku 4.5? No. It is comparable in intelligence to cost-optimized models, according to Inception Labs itself, and it enters as a candidate for high volume and low ambiguity. Deep reasoning and decisions with a high cost of error stay on the frontier. The routing policy combines the two classes.

What is Mercury 2.5's price and what does it change in the budget? US$0.20 per million input tokens and US$0.75 per million output tokens, with a launch promotion at US$0.04 and US$0.15. The budget effect does not come from price alone, it comes from cost per completed task. A model with more throughput per GPU can cost less per request even with a similar price per token, but that math depends on your volume, the batch and the number of denoising steps, and only measurement on your own load closes the number.

What is the Mercury Router and why does it matter? It is a router announced in preview by Inception Labs, alongside Mercury Voice, and still with no general availability date. It matters because it places a model vendor in the layer that decides which model serves each call, forwarding prompts to open and closed models. That confirms routing as the control plane of the AI stack, and not as a detail of the application.

Were the Augment Code and OpenCall numbers audited? Not independently. Both cases come from the Inception Labs announcement. The 82% reduction in compaction latency and the 90% cost cut are customer reports published by the primary source. OpenCall's P99, from minutes to about one second, follows the same origin.

References and Further Reading

• Introducing Mercury 2.5, Inception Labs, primary source, published on 2026-09-08 per the announcement footer; page consulted on 2026-09-15.
• Six labs above 50 on the Intelligence Index, where the intelligence frontier sits and what it changes in the route (reference reading, not Mercury 2.5's position).
• Qwen3.8-Max: context cost and what changes in routing, context cost as a routing decision vector.
• Nexforce Router, the multi-model routing layer with a single API.

What to do now with the new class on the route

The short deadline is clear: Inception Labs promised Mercury Voice and Mercury Router as previews, with no general availability date in the announcement, so the buyer who wants to prepare works with what is already dated. Mercury 2.5, its price and its speed are already an architecture decision, not a waiting one.

The question left for the next quarter is not which model is best, but who controls the decision of which model serves each call. A model vendor launching its own router answers that question from one side. On the buyer's side, the answer is to keep the routing layer under its own control, with an explicit, observable criterion.

The Nexforce Router exists for that: more than 300 models behind a single API compatible with OpenAI, with routing by cost, performance, latency and context, automatic failover between providers, budget per key and centralized observability of every call. When a new class of architecture enters production, as diffusion LLMs now have, the routing policy is what decides how much of it becomes real savings and how much becomes complexity without an owner.