OpenAI’s GPT-6 Astra can write a working script, but you will wait for it to type every token, one at a time, the way it has since the original GPT-3. Inception Labs’ Mercury 2.5 does not type. It sketches an entire answer in rough form, then refines the whole thing in parallel passes, the same way a Stable Diffusion image goes from noise to a finished picture. The result, according to Inception’s own September 8, 2026 launch numbers, is 1,107 tokens per second on widely available Nvidia GPUs, a pace no mainstream autoregressive model comes close to matching in production.
This is a comparison most buyers’ guides have skipped because the technology only became commercially credible in the past few months. Diffusion language models spent 2024 and 2025 as a research curiosity. In September 2026 they are a live purchasing decision, with a general-availability API, real pricing, and a growing list of production use cases at companies that need speed more than they need the last few points of reasoning accuracy. This article puts Mercury 2.5 next to Google’s still-experimental Gemini Diffusion and OpenAI’s flagship autoregressive model, GPT-6 Astra, using published specs, independent benchmark data, and real pricing pages, so you can decide whether a diffusion LLM belongs in your stack.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is a Diffusion LLM, and Why Does It Change the Speed Math?
Every mainstream chatbot you have used, from GPT-6 Astra to Claude to Gemini’s Flash and Pro lines, is autoregressive. It predicts the next token, appends it, then predicts the next one after that, one at a time, left to right. That is why streaming responses appear to type themselves out: the model genuinely is generating them in that order. It is also why latency scales with output length. A 2,000-token answer takes roughly twice as long as a 1,000-token one, no matter how fast the underlying hardware is, because each token depends on every token before it.
A diffusion LLM works the way an image diffusion model works. It starts with a masked or noisy version of the full output and refines the entire sequence over a small number of parallel steps, gradually replacing noise with real tokens across the whole answer at once. The approach is not new: LLaDA, an early open diffusion language model, was trained on 2.3 trillion tokens at just 8 billion parameters, with its results documented in a 2025 Zylos research review well before Mercury or Gemini Diffusion turned the idea into a shipping product. Zylos AI’s June 2026 research note on diffusion models for agentic inference describes the newer generation as “less typewriter, more editor revising a full draft at once.” Because many tokens get resolved in each pass instead of one token per forward pass, output speed becomes far less tied to answer length, and a single GPU can push a lot more tokens per second than an autoregressive model of similar quality.
The tradeoff is not free. Diffusion models generally need more careful training to reach the same reasoning depth as a comparable autoregressive model, and the field is younger, so the biggest labs (OpenAI, Anthropic, and Google’s flagship Gemini line) still ship autoregressive transformers as their primary product. Diffusion is currently a speed specialist, not yet a like-for-like intelligence replacement, and the benchmark section below shows exactly how large that gap still is.
Meet the Three Models in This Comparison
Mercury 2.5 (Inception Labs)
Inception Labs, founded by Stanford researchers Stefano Ermon, Aditya Grover, and Volodymyr Kuleshov, launched Mercury 2.5 on September 8, 2026, according to the company’s own announcement. It is a commercial, generally available API, not a research demo, and it is the model that made diffusion LLMs a mainstream purchasing option rather than an academic footnote. That trajectory started with Mercury 2 itself, which Inception released back in February 2026 at an input price of $0.25 per million tokens and which LLMBase measured at a 77.0% GPQA score, already a respectable reasoning baseline for a speed-first model. Mercury 2.5 extends its predecessor’s context window from 128K to 260K tokens, and adds tunable reasoning, native tool use, JSON mode, and parallel tool calls, features enterprise buyers expect from a production model rather than a research preview.
Gemini Diffusion (Google DeepMind)
Google’s diffusion effort remains, as of September 2026, an experimental research preview. The official Gemini Diffusion page publishes a sampling speed figure and little else: no public context window, no published pricing, and no listing alongside Gemini’s production Flash and Pro tiers on Google’s API pricing pages. It is a proof of concept Google keeps updating rather than a shipped product, which is itself a useful data point about where the largest AI labs think diffusion currently sits in their roadmap.
GPT-6 Astra (OpenAI) — the autoregressive baseline
GPT-6 Astra is included here not because it competes for the same use cases as a diffusion model, but because it is the reigning autoregressive flagship and the model most likely to be sitting in a production stack that a team is now evaluating diffusion against. OpenAI released it to approved users on September 3, 2026, with general availability the following day. It carries a 1M-token context window and standard pricing of $10 per million input tokens and $50 per million output tokens for prompts under 272K tokens, rising to $20 input and $75 output above that threshold.
Full Specs Comparison Table
| Spec | Mercury 2.5 | Gemini Diffusion | GPT-6 Astra |
|---|---|---|---|
| Developer | Inception Labs | Google DeepMind | OpenAI |
| Architecture | Diffusion (parallel refinement) | Diffusion (parallel refinement) | Autoregressive transformer |
| Release status | Generally available (API) | Experimental research preview | Generally available (API + ChatGPT + Azure + AWS Bedrock) |
| Release date | September 8, 2026 | Ongoing preview, actively updated through August 2026 | September 3-4, 2026 |
| Context window | 260,000 tokens | Not publicly disclosed | 1,000,000 tokens |
| Max output tokens | 65,536 | Not publicly disclosed | Not separately published |
| Output speed (vendor claim) | 1,107 tokens/sec | 1,479 tokens/sec (excl. 0.84s overhead) | Not publicly disclosed |
| Independent throughput check | Predecessor Mercury 2 measured at 720.6 tok/s by Artificial Analysis | Third-party testers report 850-2,000 tok/s range | Not disclosed by independent trackers in current data |
| List price, input | $0.20 / 1M tokens | Not published | $10.00 / 1M tokens (up to 272K context) |
| List price, output | $0.75 / 1M tokens | Not published | $50.00 / 1M tokens (up to 272K context) |
| Launch promo pricing | $0.04 input / $0.15 output (80% off) | N/A | N/A |
| Long-context pricing | N/A (flat rate) | N/A | $20 input / $75 output above 272K |
| Reasoning mode | Tunable reasoning | Not documented as configurable | Yes, native |
| Tool use / function calling | Native, plus parallel tool calls | Not documented | Yes |
| Access model | Self-serve API, OpenRouter listing | Demo/preview interface only | API, ChatGPT paid tiers, Azure, AWS Bedrock |
| GPQA-style reasoning score | Not independently published in this comparison | 40.4 (vs. 56.5 for Gemini 2.0 Flash-Lite) | 96% on GPQA per third-party benchmark trackers |
The gaps in the Gemini Diffusion row are not an oversight on our part. Google genuinely has not published a context window, formal pricing, or a production benchmark suite for the model, according to aggregated review data corroborated by Google’s own demo page. That absence is itself informative: well over a year after Google first showed Gemini Diffusion publicly, it is still being treated internally as a research artifact rather than a shippable product, even as Inception Labs has taken the same underlying idea to a paid, general-availability API twice over.
Benchmarks: Speed Data From Three Independent Sources
Speed claims from a vendor’s own blog post are a starting point, not a verdict, so this section leans on independent measurement wherever it exists.
Inception’s own numbers put Mercury 2.5 at 1,107 tokens per second on widely available Nvidia GPUs. That is a step down from the raw figure recorded for its predecessor, Mercury 2, which Inception listed at 1,009 tokens per second on Nvidia’s Blackwell chips, a number that the independent benchmarking firm Artificial Analysis actually measured lower, at roughly 720.6 tokens per second on Mercury 2’s live API endpoint. That independent over-shoot is unusual in AI benchmarking, where vendor numbers typically beat third-party reproductions, and it is one reason Mercury’s speed claims carry more weight than most, especially given LLMBase’s separate finding that Mercury 2, priced at $0.25 per million input tokens at its February 2026 launch, had already reached a 77.0% GPQA score before Mercury 2.5 arrived.
Google’s Gemini Diffusion demo page lists a sampling speed of 1,479 tokens per second, excluding a fixed 0.84-second overhead per request. A technical write-up analyzing that figure calculated an underlying throughput of 1,456 output tokens per second in a single-GPU, FP8, batch-size-one test on an Nvidia H100, derived from a 13.56-millisecond average execution time per diffusion forward pass. Separately, independent testers reported real-world generation in the 850 to 2,000 tokens-per-second range, a wide band that reflects how much diffusion throughput still depends on prompt length, hardware, and batch configuration rather than being a single fixed number the way autoregressive tokens-per-second figures usually are.
For the autoregressive side of the comparison, OpenAI has not published a tokens-per-second figure for GPT-6 Astra in its pricing or model documentation, and no independent benchmark tracker in the current data set has filled that gap with a verified number. That absence is itself the point: frontier autoregressive models are not marketed on raw throughput because it is not their selling point. A June 2026 research note from Zylos AI put typical frontier autoregressive output around 100 tokens per second, compared with over 1,000 tokens per second for Mercury-class diffusion models, a roughly tenfold gap that lines up with the harder numbers gathered here even without an official GPT-6 Astra figure to plug into the comparison directly.
A third data point comes from outside Inception and Google entirely. NVIDIA released its Nemotron-Labs-Diffusion family, in 3B, 8B, and 14B sizes, on May 20, 2026, and MarkTechPost reported the models delivered six times more tokens per forward pass than Qwen3-8B, a separate confirmation that parallel decoding scales across model sizes rather than being a one-vendor trick. DiffusionGemma, an open research model detailed in an arXiv technical report published in August 2026, reached roughly 1,500 output tokens per second on a single previous-generation Nvidia H100, which the paper’s authors describe as a 2.5x speedup over Mercury 2 while remaining highly competitive with it on quality. That is now a fourth independent research group landing in the same fast-generation neighborhood as Inception, Google, and NVIDIA, which is meaningfully stronger evidence than any single vendor’s claim on its own.
Where Diffusion Still Loses: Reasoning Benchmarks
Speed is not the whole story, and the clearest illustration sits inside Google’s own Gemini Diffusion evaluation data. On GPQA, a graduate-level reasoning benchmark, Gemini Diffusion scored 40.4 against 56.5 for Gemini 2.0 Flash-Lite, an autoregressive model from the same company that is itself considered a lightweight, budget-tier option rather than a flagship. On Global MMLU, Gemini Diffusion posted 69.1 against 79.0 for Flash-Lite. That is not a narrow gap. It is a double-digit deficit against a model Google does not even market as its strongest, which explains why Gemini Diffusion has stayed in preview rather than graduating to a production tier alongside Flash and Pro.
GPT-6 Astra, by contrast, leads frontier reasoning leaderboards outright, with a 96% score on GPQA and a 95% score on ARC-AGI-2 according to benchmark trackers aggregating September 2026 data. That is the real tradeoff buyers are making: Mercury 2.5 and Gemini Diffusion win decisively on raw generation speed, while GPT-6 Astra and other autoregressive flagships still win decisively on the hardest reasoning tasks. Inception has not published a GPQA or comparable frontier-reasoning score for Mercury 2.5 in the sources reviewed for this piece, which is its own signal: the company is positioning the model against cost-optimized, lightweight competitors like GPT-5.6 Luna’s Low tier, Gemini 3.5 Flash-Lite, and Claude Haiku 4.5, not against flagship reasoning models.
Latency in Practice: Why Milliseconds Add Up at Scale
Raw tokens-per-second numbers are easy to skim past, so it helps to translate them into what a user actually experiences. A typical customer-support response runs somewhere between 150 and 300 output tokens. At GPT-6 Astra’s estimated frontier-tier pace, generating a 250-token answer takes noticeably longer than at Mercury 2.5’s 1,107 tokens per second, where the same response resolves in well under a quarter of a second once the request reaches the model. That difference does not matter much in a chat window where a user is reading along as text streams in. It matters enormously in a voice call, where the model has to finish generating before speech synthesis can even begin, and where every extra second of silence reads to a caller as the system being broken rather than thinking.
The same math compounds in agentic workflows that chain multiple model calls together. A search agent that issues five sequential calls, one to plan the search, one to rank results, one to extract facts from each of three retrieved pages, pays the per-call latency tax five times over before it can hand a final answer back to the user. Compressing each of those calls by a factor of ten, which is roughly the gap Mercury 2.5 claims over a typical frontier autoregressive model, can be the difference between an agent that responds in two seconds and one that takes twenty. That is precisely why Inception names search agents and coding subagents, both multi-call, latency-stacking workloads, as flagship use cases for Mercury 2.5 rather than single-turn chat.
It is worth being honest about the limits of this math, too. Time to first token and network overhead do not disappear just because generation speed goes up, and Google’s own Gemini Diffusion figures include a fixed 0.84-second overhead on top of the 1,479 tokens-per-second sampling rate, a reminder that a diffusion model’s advantage grows with response length and shrinks, sometimes to nothing, on very short outputs like single-word classifications or yes/no answers.
Why the Biggest AI Labs Are Still Betting on Autoregressive Models
If diffusion is genuinely ten times faster, a reasonable question is why OpenAI, Anthropic, and Google have not simply switched their flagship products over to it. The answer sits in the benchmark gap documented earlier in this piece. Every flagship model shipped by a major lab in 2026, from GPT-6 Astra to Claude’s Opus and Fable lines to Gemini’s own Pro tier, is autoregressive, and all of them are marketed primarily on reasoning depth, coding accuracy, and agentic reliability rather than raw throughput. Google’s decision to keep Gemini Diffusion in research preview for well over a year, even as the underlying architecture demonstrably works at commercial scale for Inception, is the clearest signal available that the company’s own internal evaluations have not yet cleared the bar its production Gemini tiers are held to.
That caution is not unique to Google. No frontier lab has published a diffusion model that leads its own autoregressive lineup on hard reasoning benchmarks like GPQA, SWE-bench, or ARC-AGI. Inception itself, the company furthest along in commercializing the architecture, positions Mercury 2.5 against cost-optimized, lightweight competitors such as GPT-5.6 Luna’s Low tier, Gemini 3.5 Flash-Lite, and Claude Haiku 4.5, not against GPT-6 Astra, Claude Opus, or Gemini’s Pro tier. That is a deliberate and honest positioning choice, not a limitation Inception is hiding, and it tells buyers exactly where the technology currently sits in the capability spectrum: a strong, fast alternative to small, cheap autoregressive models, not yet a replacement for a frontier reasoning engine.
The more interesting question for 2027 and beyond is whether that gap closes. DiffusionGemma’s arXiv authors describe their model’s quality as highly competitive with Mercury 2, which suggests the ceiling on diffusion quality has not yet been reached, and academic research catalogued in community trackers like the ai4s-research GitHub list continues to explore ways to close the reasoning gap without sacrificing the parallel-generation speed advantage. For now, the practical reality in September 2026 is architectural specialization: diffusion for speed-critical, well-scoped tasks, and autoregressive transformers for anything that needs to reason its way through genuine ambiguity.
Pricing Comparison: What You Actually Pay
| Model | List input (per 1M) | List output (per 1M) | Effective launch/promo price | Notes |
|---|---|---|---|---|
| Mercury 2.5 | $0.20 | $0.75 | $0.04 input / $0.15 output (80% off at launch) | Flat rate regardless of context length |
| Gemini Diffusion | Not published | Not published | N/A | Not listed on Google’s Gemini API pricing page; demo access only |
| GPT-6 Astra (standard) | $10.00 | $50.00 | N/A | Prompts up to 272K input tokens; cached input $1.00, cache writes $12.50 |
| GPT-6 Astra (long-context) | $20.00 | $75.00 | N/A | Applies above 272K input tokens; cached input $2.00, cache writes $25.00 |
| DeepSeek V4 Flash (reference, fast autoregressive) | $0.14 | $0.28 | Cached input as low as $0.0028 | Cited by regolo.ai’s September 2026 benchmark writeup |
| GLM-5.3-Flash (reference, fast autoregressive) | $0.15 | $0.50 | 50% launch promo: $0.075 / $0.25 | Same regolo.ai source; included for scale comparison |
The comparison rows for DeepSeek V4 Flash and GLM-5.3-Flash are there deliberately. They are not diffusion models, but they are the fast, cheap autoregressive tier that Mercury 2.5 is actually competing against in procurement conversations, not GPT-6 Astra. At list price, GPT-6 Astra’s output tokens cost roughly 67x more than Mercury 2.5’s, and at Mercury’s launch promo rate the gap widens to over 300x. Against DeepSeek V4 Flash, a genuinely cheap autoregressive model, Mercury 2.5’s list price is still higher per token. What Mercury sells is not the lowest price per token; it is the lowest price per second of generation, because it produces roughly ten times as many tokens in the same wall-clock time.
Cost Per Completed Task: A Worked Example
Per-token pricing tables are useful for procurement spreadsheets, but they hide the number that actually matters for a production budget: what does it cost to finish one real task, end to end. Take a common workload, summarizing a 3,000-word support ticket thread into a 150-word internal note, roughly 4,000 input tokens and 200 output tokens per call. The table below walks that exact task through each model’s list pricing to show how the numbers actually shake out once input and output tokens are combined.
| Model | Input cost (4,000 tokens) | Output cost (200 tokens) | Total cost per task | Approx. generation time at listed speed |
|---|---|---|---|---|
| Mercury 2.5 (list price) | $0.0008 | $0.00015 | $0.00095 | Well under 1 second (1,107 tok/s) |
| Mercury 2.5 (launch promo) | $0.00016 | $0.00003 | $0.00019 | Well under 1 second |
| GPT-6 Astra (standard) | $0.04 | $0.01 | $0.05 | Not publicly disclosed; several seconds typical for AR models at this length |
| DeepSeek V4 Flash (reference) | $0.00056 | $0.000056 | $0.00062 | Under 2 seconds (108 tok/s) |
At this task size, GPT-6 Astra’s total cost per completed summary runs roughly 53x higher than Mercury 2.5’s list price and over 260x higher than Mercury’s launch promo rate. That gap will not hold for every workload, GPT-6 Astra’s much larger context window and stronger reasoning make it the only viable choice once a task requires genuine multi-step judgment, but for a well-defined, short-output task like ticket summarization, the price difference is large enough that most engineering teams will at least benchmark a diffusion model before defaulting to a frontier reasoning model out of habit.
Five Real-World Use Cases Where Diffusion Speed Matters
Voice assistants and real-time agents. Inception explicitly positions Mercury 2.5 for voice pipelines, where every millisecond of generation latency is audible as dead air to a caller. An autoregressive model generating at roughly 100 tokens per second introduces a noticeable pause before a multi-sentence response finishes; a diffusion model generating the full response in parallel can close that gap enough to feel conversational rather than robotic.
Search and retrieval agents. Search agents that summarize multiple retrieved documents on every query benefit disproportionately from throughput, because the summarization step happens on the critical path of every single search request, not occasionally. Inception names this as one of its three flagship use cases for Mercury 2.5, alongside voice and coding subagents.
Coding subagents and autocomplete. Editor-integrated code completion has to feel instantaneous or developers turn it off. Mercury’s predecessor, Mercury Coder, was built specifically for this niche, and the speed advantage compounds when a single developer session triggers dozens of small completions per minute rather than one long chat response.
High-volume structured data extraction. Batch pipelines that pull structured fields out of documents at scale care about total throughput per dollar far more than they care about frontier reasoning depth. Mercury 2.5’s native JSON mode and parallel tool calls target exactly this workload, where the task is well-defined and repetitive rather than open-ended.
Research and internal tooling at Google. Gemini Diffusion’s continued existence as an internal research preview, rather than a shipped product, is itself a real-world use case: Google is using it to explore the architecture’s limits and gather benchmark data, like the GPQA and Global MMLU scores cited above, before deciding whether it belongs in a production tier. That is a legitimate, if less glamorous, application of the technology.
Use-Case Recommendations: Which Architecture Fits Your Workload
- Real-time voice or chat interfaces where latency is felt by a human in the moment: Mercury 2.5. Its throughput advantage translates directly into a faster-feeling product, and its launch pricing makes the switch cheap to test.
- Frontier reasoning, complex multi-step agentic tasks, or anything scored against GPQA-level difficulty: GPT-6 Astra or another autoregressive flagship. The 96% GPQA score is not something any current diffusion model claims to match.
- High-volume batch extraction or classification at massive scale: Mercury 2.5 for the speed, or DeepSeek V4 Flash if the cheapest possible per-token price matters more than raw throughput.
- Long-document analysis needing more than 260K tokens of context: GPT-6 Astra, whose 1M-token window is roughly four times larger than Mercury 2.5’s 260K ceiling.
- Experimental or research workloads where you want to track where diffusion is headed without committing spend: Gemini Diffusion’s demo interface, understanding that it is not production-ready and carries no SLA or published pricing.
- Coding autocomplete and editor integrations: a diffusion model in the Mercury family, following the precedent set by the coding-specific Mercury Coder release.
The Open-Source Diffusion Landscape: DiffusionGemma and Beyond
Mercury and Gemini Diffusion are not the only entrants. DiffusionGemma, which Google DeepMind released on June 10, 2026 under an Apache 2.0 license and documented further in the arXiv technical report referenced above, is a research model built on Google’s Gemma line that packs 26B total parameters with about 3.8B active per pass, according to a June 2026 breakdown by Digital Applied, and reaches roughly 1,500 tokens per second on a single H100, the fastest raw figure of any model discussed in this piece, while its authors describe its quality as highly competitive with Mercury 2 rather than clearly ahead of it. Unlike a closed research artifact tied only to an arXiv paper, its Apache 2.0 license means it is freely downloadable and directly comparable on architecture even without a hosted commercial API or published pricing, and it matters for a different reason too: it shows the throughput gains Inception and Google have demonstrated are reproducible by a third, independent team, not an artifact of one company’s specific engineering choices.
Broader academic and corporate-lab work on diffusion language models, cataloged in community-maintained lists like the ai4s-research “awesome-diffusion-llm” repository on GitHub, points to a growing field that includes open efforts such as the LLaDA family and other university-led projects. The LLaDA team itself kept iterating through 2026, publishing iLLaDA-8B-Base and iLLaDA-8B-Instruct on GitHub on June 24, 2026 with reported gains in both training efficiency and downstream benchmarks. That family got substantially more serious in 2026: Ant Group released LLaDA2.2-flash, a 100B-parameter diffusion model, in July 2026, according to AI Wiki, and followed it in September 2026 with LLaDA2.2-mini, a leaner 16B-total, roughly 1.4B-active model with a 128K-token context window, per LLM Releases. None of these have reached the commercial maturity of Mercury 2.5, but they establish that diffusion is not a single-vendor bet confined to Inception Labs. The architecture itself is being explored across at least four separate research lineages simultaneously, spanning Inception, Google, NVIDIA, and Ant Group, which is a stronger signal for the technology’s staying power than any one company’s roadmap.
Migration Guide: Moving a Workload From an Autoregressive Model to a Diffusion LLM
Switching a production endpoint from GPT-6 Astra or a similar autoregressive model to Mercury 2.5 is closer to a configuration change than a rebuild, provided you follow a disciplined rollout.
- Audit your current context needs. Mercury 2.5 tops out at 260,000 tokens, well short of GPT-6 Astra’s 1M-token ceiling. If any of your prompts routinely exceed 260K tokens, plan for a retrieval-and-chunking step or keep those specific calls on an autoregressive model.
- Get API access. Mercury 2.5 is available directly through Inception’s own API and is also listed on OpenRouter, which is useful if you already route traffic through OpenRouter for other models and want a drop-in comparison.
- Start with the launch promo tier for testing. At $0.04 input and $0.15 output per million tokens, running a parallel evaluation costs a fraction of what the same test would cost against GPT-6 Astra’s $10/$50 pricing.
- Re-test your prompts, not just your code. Diffusion models generate the full response through iterative refinement rather than token-by-token, so prompt patterns tuned for autoregressive streaming, like asking a model to think step by step and stream its reasoning, may need adjustment for a model that natively supports tunable reasoning instead.
- Turn on JSON mode and tool use explicitly. Mercury 2.5 supports native tool use, parallel tool calls, and JSON mode, but these are model features you configure at the request level, not automatic behaviors inherited from your old autoregressive integration.
- Benchmark quality on your own task, not just published scores. Given the GPQA gap documented for Gemini Diffusion against even a lightweight autoregressive model, do not assume a diffusion model will match your current model’s accuracy on reasoning-heavy tasks without direct testing.
- Route by workload, not wholesale. Most teams migrating in September 2026 are not replacing their flagship model outright; they are adding a routing layer that sends latency-sensitive, well-defined tasks like voice, autocomplete, and structured extraction to Mercury 2.5 while keeping complex reasoning on GPT-6 Astra or a comparable frontier model.
- Monitor cost per completed task, not just cost per token. Because diffusion models can need more compute per token in some configurations even while producing more tokens per second overall, the meaningful comparison is total cost and total latency per finished response, not the headline per-token price alone.
- Set a rollback threshold before you go live. Decide in advance what quality or latency regression triggers a fallback to your previous model, and wire that into your routing logic rather than deciding reactively after a production incident.
- Watch the launch promo expiration. Inception’s 80%-off introductory pricing on Mercury 2.5 is explicitly framed as a launch promotion, not a permanent rate, so budget for the list price of $0.20/$0.75 per million tokens once the promo period ends.
Pros and Cons
Mercury 2.5
Pros: Roughly tenfold throughput advantage over typical frontier autoregressive models; aggressive launch pricing; native tool use, JSON mode, and parallel tool calls built for production agentic workloads; generally available today rather than gated behind a waitlist.
Cons: 260K context window is a fraction of GPT-6 Astra’s 1M-token ceiling; Inception has not published head-to-head frontier reasoning scores against GPQA-class benchmarks; list pricing after the promo period is still above the cheapest fast autoregressive models like DeepSeek V4 Flash on a pure per-token basis.
Gemini Diffusion
Pros: Backed by Google DeepMind’s research and engineering resources; the highest raw sampling speed claim of the three models compared here, at 1,479 tokens per second; free to experiment with through the demo interface.
Cons: Not production-ready; no published context window, pricing, or SLA; documented double-digit accuracy deficit against Google’s own lightweight Flash-Lite model on GPQA and Global MMLU; no committed timeline to general availability in current public materials.
GPT-6 Astra
Pros: Leading frontier reasoning scores, at 96% GPQA and 95% ARC-AGI-2 per current trackers; 1M-token context window; mature multi-platform availability across the OpenAI API, ChatGPT, Azure, and AWS Bedrock.
Cons: Standard output pricing of $50 per million tokens is roughly 67x Mercury 2.5’s list price and over 300x its launch promo price; no independently verified throughput figure; latency scales with output length in a way diffusion models are specifically designed to avoid.
Sample API Request: Mercury 2.5
Mercury 2.5 exposes an OpenAI-compatible chat completions endpoint, which is one reason migration is relatively low-friction for teams already using an OpenAI-style SDK.
curl https://api.inceptionlabs.ai/v1/chat/completions \
-H "Authorization: Bearer $INCEPTION_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "mercury-2.5",
"messages": [
{"role": "user", "content": "Summarize this support ticket in two sentences."}
],
"reasoning": "low",
"response_format": {"type": "json_object"},
"max_output_tokens": 512
}'The “reasoning” parameter is where Mercury 2.5’s tunable reasoning feature lives; setting it low favors raw throughput for straightforward tasks, while a higher setting trades some speed for more deliberate multi-step generation on harder prompts.
The Verdict: Pick the Architecture for the Job, Not the Headline
The data does not support a single winner, and treating this as a horse race misreads what each model is built for. Mercury 2.5 wins decisively on throughput, at roughly 1,107 tokens per second against a typical frontier autoregressive baseline of around 100 tokens per second, and its launch pricing of $0.04/$0.15 per million tokens makes testing it essentially free for most teams. GPT-6 Astra wins decisively on reasoning depth, with a 96% GPQA score and a 1M-token context window neither diffusion model in this comparison comes close to matching. Gemini Diffusion, despite posting the single highest raw speed claim at 1,479 tokens per second, is not a real production option yet: Google’s own benchmark data shows it trailing its own lightweight Flash-Lite model by double digits on GPQA and Global MMLU, and there is no public pricing or context window to plan around.
The practical recommendation for most engineering teams evaluating this in September 2026: treat Mercury 2.5 as a genuine addition to your model routing table for latency-sensitive, well-scoped tasks like voice, search summarization, and coding autocomplete, keep GPT-6 Astra or a comparable frontier model for anything that needs deep multi-step reasoning or context beyond 260K tokens, and watch Gemini Diffusion as a leading indicator of where Google’s own thinking is headed, without building anything on it in production yet.
Frequently Asked Questions
Is Mercury 2.5 faster than every autoregressive AI model?
It is faster than typical frontier autoregressive models, which generate around 100 tokens per second according to Zylos AI’s June 2026 research note, against Mercury 2.5’s 1,107 tokens per second. Some fast, lightweight autoregressive models narrow that gap somewhat, but none in the current public data match Mercury’s throughput.
Can I use Gemini Diffusion in a production app today?
Not in any documented, supported way as of September 2026. It remains an experimental research preview with no published context window, pricing, or service-level agreement, and it is not listed among Google’s production Gemini API tiers.
Why is Mercury 2.5’s context window so much smaller than GPT-6 Astra’s?
Diffusion models process the entire output sequence in parallel across each refinement step, which makes very long contexts more computationally demanding to scale than in an autoregressive architecture. Inception grew Mercury’s context window from 128K to 260K tokens between Mercury 2 and Mercury 2.5, a meaningful jump, but it remains well short of GPT-6 Astra’s 1M-token ceiling.
Does a diffusion LLM cost less to run than an autoregressive model?
It depends on what you are measuring. On a per-token basis, Mercury 2.5’s list price of $0.20/$0.75 per million tokens is actually higher than the cheapest fast autoregressive models like DeepSeek V4 Flash at $0.14/$0.28. But because Mercury generates roughly ten times as many tokens per second, its effective cost per completed task, and especially its cost per second of user-facing latency, can be substantially lower for throughput-sensitive workloads.
Is diffusion going to replace autoregressive models like GPT-6 Astra?
Nothing in the current benchmark data supports that conclusion. Diffusion models currently trail comparable autoregressive models on reasoning-heavy benchmarks, sometimes by a wide margin, as shown by Gemini Diffusion’s GPQA score against Google’s own Flash-Lite model. The more likely near-term outcome is architectural specialization, with diffusion handling latency-critical, well-scoped tasks and autoregressive models remaining the default for complex reasoning.
What happened to Mercury Coder, Inception’s earlier model?
Mercury Coder was Inception’s earlier, coding-focused diffusion model and predates Mercury 2 and Mercury 2.5. It established the company’s initial production use case in editor-integrated code completion, a workload that benefits directly from diffusion’s speed advantage because completions need to feel instantaneous during active typing.
How do I access Mercury 2.5’s API?
Mercury 2.5 is available directly through Inception Labs’ own API using an OpenAI-compatible endpoint, and it is also listed on OpenRouter for teams that already route traffic through that platform and want to A/B test it against other models without a separate integration.
Are there open-source diffusion LLMs I can self-host?
Yes, and the field expanded quickly through 2026. DiffusionGemma, which Google DeepMind released June 10, 2026 under an Apache 2.0 license and documented in an August 2026 arXiv technical report, is a research-grade open diffusion model built on Google’s Gemma architecture with 26B total parameters. NVIDIA’s Nemotron-Labs-Diffusion family (3B, 8B, and 14B, released May 20, 2026) and Ant Group’s LLaDA2.2 line, spanning the 100B-parameter LLaDA2.2-flash from July 2026 to the smaller, 128K-context LLaDA2.2-mini from September 2026, are also freely available for self-hosting. Community-maintained catalogs like the ai4s-research “awesome-diffusion-llm” list on GitHub track additional academic diffusion LLM projects, though none has yet reached the commercial polish or hosted API maturity of Mercury 2.5.
