Inception Mercury 3 Review (2026): 1,068 Tokens/s, No Weights

A model that drafts the whole answer at once instead of typing it out, claims four to eight times the speed of the models it is priced against, and hands you no checkpoint to check any of it with.

By AI Tool Scout · Published October 21, 2026 · 18 min read

What Is Inception Mercury 3?

Inception Mercury 3 is the flagship of Inception's diffusion language model line, announced on Monday, October 19, 2026 — the date on the company's own launch post at inceptionlabs.ai — and reported by most outlets on October 20. Inception calls it "the most capable diffusion-based LLM released to date," which is a claim with a low bar and a real point behind it: no other company is shipping commercial text diffusion at this scale, so the comparison set is mostly Inception's own previous releases. It replaces Mercury 2.5, which shipped only weeks earlier with a 260,000-token context, and Inception has already closed Mercury 2 and 2.5 to new customers, with existing accounts keeping access only until November 15, 2026.

The company behind it is Inception, founded by Stefano Ermon (CEO), Volodymyr Kuleshov and Aditya Grover, researchers with Stanford roots who worked on diffusion methods before applying them to language. It shipped the first commercially available diffusion LLM, Mercury, in February 2025, at roughly 1,100 tokens per second on H100s in a latency-optimised regime — a figure that sounds like today's headline and is 20 months old. Mercury 2 added reasoning in 2026, Mercury 2.5 pushed context to 260K, Mercury Voice arrived on September 29, 2026, and Mercury 3 is the fourth generation. The line's positioning has never been the capability ceiling. It has been speed at a fixed quality, and the pitch to buyers is that latency, not intelligence, is what breaks a browser agent or a voice agent in production.

Diffusion, in plain English

An autoregressive model writes one token, feeds it back in, writes the next, and repeats. Every token depends on the one before it, so the decode step is a chain that cannot be parallelised across positions — that serial dependency is the structural bottleneck every inference optimisation of the last three years has been working around. A diffusion LLM does something different. It allocates a block of placeholder tokens for the whole answer, then denoises that block: at each pass the model looks at every position at once and rewrites all of them, so the text starts as a rough sketch and sharpens over a handful of iterations. It is the same coarse-to-fine trick that turns static into a photo in an image generator, applied to tokens.

Two consequences follow, and both matter commercially. The first is speed: because a pass fills many positions simultaneously, throughput per forward pass is far higher than a decode loop, and — this is Inception's actual argument — it degrades more gracefully with model size, which is why a model "more than 40× larger than Mercury 1" can still run at roughly Mercury 1's speed. If that holds, it is a bigger deal than any single benchmark, because it means the usual trade of intelligence for latency is not a law. The second is the cost: the model commits to a block and refines it rather than revising a decision token by token, which is fine for fluent prose, and is not obviously fine for tasks where an early choice becomes load-bearing — a tool call whose arguments must be exactly right, a multi-step plan whose step 4 depends on step 2, a long-context answer that has to retrieve one specific sentence out of 900,000 tokens. Keep that second point in mind for the benchmark section, because Inception's own table is where it shows up.

What Inception has not disclosed is as notable as what it has. No parameter count — only "more than 40× Mercury 1" and "3× the intelligence of Mercury 1 mini." No GPU model behind the 1,068 tokens per second. No technical paper and no model card at launch, unlike the Mercury Coder report Inception published on arXiv for the first generation. And no weights, no licence, no checkpoint size. Anyone quoting an architecture diagram of Mercury 3 is drawing it themselves.

Key Features

• 1,000,000-token context, 131,072-token output ceiling. Up from 260K context and 65,536 output on Mercury 2.5 — a 3.85× window and a 2× output limit, which is the most concrete upgrade in the release.
• Parallel denoising instead of sequential decode. The architectural difference, and the reason the speed number exists at all.
• Four reasoning levels: instant, low, medium, high. The instant setting is the important one — it lets a classifier or router skip thinking entirely, which is exactly what MiniMax M3.1 Flash will not let you do.
• Tool calling and structured outputs. Both listed on the model card, on an OpenAI-compatible v1/chat/completions endpoint at the model ID mercury-3, with documented support through AISuite, LiteLLM and LangChain.
• Text in, text out. No image input, no audio, no video. In a price band where MiniMax accepts video, this is a real gap rather than a footnote.
• Temperature 0.5 to 1.0. Documented, narrow, and it means no deterministic temperature-zero mode.
• Cached input at 10% of the input rate. $0.02 per million at list, $0.01 during the promotion — the same 90% discount structure MiniMax uses, at a higher absolute number.
• Four routes. The Inception API Platform, plus OpenRouter (inception/mercury-3), Baseten and Vercel AI Gateway, with enterprise deployments offering dedicated capacity, autoscaling, compliance controls and configurable data retention.
• A product ladder, not one model. Mercury Voice at under 170 ms time to first token for voice agents (128K context, 50,000 max output; Inception enables it per organisation through a contact-sales step, so it is not self-serve), and Mercury Decide for high-volume classification and scoring ($0.04 per million input, output reported but not billed).
• 100 million free tokens on a new API key. A one-time pilot grant, and worth roughly $20–70 of usage depending on your input/output mix.
• No open weights. Listed here because it is a feature of the product whether or not you like it: the only way to run this model is to rent it.

The Speed Claim: 1,068 Tokens/Second, or 243?

This is the number the launch is built on, so it deserves the scrutiny the launch post does not give it. Inception's figure is 1,068 output tokens per second on NVIDIA GPUs; the GPU generation is not named anywhere in the announcement, which makes the number unreproducible even in principle. OpenRouter, which listed the model on October 16 and confirmed it went live, published a different picture from actual traffic.

Vendor figures and third-party figures are not like-for-like and are printed together deliberately. OpenRouter's median covers whichever provider served each request, including queueing and prompt prefill; Inception's figure is a throughput benchmark on its own stack. Neither is a latency guarantee.

Three things are true at once here, and separating them is the whole job.

• The measured number is a quarter of the claim, and it is still fast. At ~243 tokens per second on live traffic, Mercury 3 is roughly in line with the ~240 Inception's own table assigns to Claude Haiku 5.5 and about twice its ~130 for GPT-6 Luna. That is not a scandal; it is what a marketplace median looks like when it includes providers running at different batch sizes against prompts of unknown length. But it does mean the honest claim is "fastest or near-fastest in its class," not "four to eight times faster," and any latency budget written on 1,068 is fiction.
• The gap is mostly about where the time goes, not about decode. OpenRouter's own arithmetic is instructive: 3.29 s end to end minus 1.40 s to first token leaves 1.89 s of writing, and at 243 tokens/s that is a reply of about 460 tokens. At that length, 43% of the wall clock is spent waiting for the first token, which is prefill and queueing. Diffusion can be excellent at decode and still feel slow if prefill is not fast, which is precisely why Inception sells a separate Mercury Voice tuned for time to first token under 170 ms rather than claiming Mercury 3 solves it.
• Inception's own pages disagree with each other. The launch post says "4–8× faster." The models page says "5x greater speed." Both were live in the same week. Neither states which model, at which effort level, on which GPU, at which output length. Two different multiples from one company is not a rounding difference; it is a sign that the number is marketing rather than a specification.

Benchmarks: 12 Rows, 8 Wins, 4 Losses, All First-Party

Inception published a twelve-row table at medium effort, against GPT-6 Luna and Claude Haiku 5.5. Reproduced as published:

All figures vendor-reported by Inception as of October 19, 2026, at medium effort for all three models, on harnesses Inception selected. No independent reproduction existed at the time of writing. The table is reproduced from the launch material; the launch post presents it graphically.

Mercury 3 leads 8 of 12 rows, which is what the coverage repeated. The four it loses are more informative than the eight it wins.

• It loses agentic coding on DeepSWE v1 by 5.3 points — 46.31 against Claude Haiku 5.5 at 51.62. Read that against the same model's 51.08 on SWE-Bench Atlas, which is roughly 18 points ahead of both rivals. Two agentic coding benchmarks, opposite verdicts, one vendor's table. The useful conclusion is not "Mercury 3 is bad at code" or "Mercury 3 is great at code" but that agentic coding is not one capability: SWE-Bench Atlas rewards reading a repository and producing a patch, DeepSWE rewards holding exact state across a long chain of tool calls and edits. The first is a long-context shape, the second is a sequential-state shape, and a model that denoises a block in parallel is structurally better suited to the first.
• It loses long-context recall on MRCR v2 — 75.50 against Haiku 5.5 at 78.40, though it beats Luna's 62.72 comfortably. It also trails Luna narrowly on AA-LCR v1.1 at 77.67 against 78.30. The headline is a 1M window; the evidence is that retrieval at depth is competitive rather than class-leading, and no needle-in-a-haystack test at 900K was published.
• It loses factual recall on AA-Omniscience by half a point — 46.44 against Luna's 46.94. Small, and worth noting anyway because parameter count is undisclosed and knowledge density is what parameter count usually buys.
• The wins are real where they are largest. +15.0 on IFBench over Luna is the single biggest margin in the table and it is the capability that a voice agent or a support bot lives on: follow the system prompt exactly, at speed. τ³-bench Banking at 30.24 against 13.06 for Haiku is more than double on agent customer service. Those two, plus the SWE-Bench Atlas gap, are the claims worth taking seriously.

Pricing: $0.20 / $0.70, or Half That Until Further Notice

Every figure below is in US dollars, checked on October 21, 2026, against Inception's models page and platform documentation. The rate card has no peak and off-peak split.

Three lines in that table are more interesting than the flagship's. Mercury Decide bills input at $0.04 per million and nothing for output, on a dedicated v1/decisions endpoint that returns calibrated probabilities, categorical choices or ordinal scores. If your workload is "classify ten million support tickets," that is a radically cheaper shape than any chat model — a tenth of Mercury 3's input price with no output leg at all — and it is the part of Inception's portfolio with no direct equivalent at this price. Mercury Voice at $0.40/$1.50 (promo $0.20/$0.75) is priced above the text model because time to first token under 170 ms is a harder engineering problem, and Inception says it is already running at Audivi AI, Altur and OpenCall. And Mercury 2.5 costs $0.75 output against Mercury 3's $0.70 — the new flagship is cheaper per output token than the model it replaces, which is the one unambiguous win in the rate card.

What a real agent run costs

Headline rates are useless without a token count, so here is the same model we use across these reviews. A 30-step agent run — a coding or browser agent that calls a tool, reads the result, thinks, calls another — with a 6,000-token system prompt and tool schema re-sent every step, 1,200 tokens of tool output and 600 tokens of reasoning plus visible answer per step. Each step re-sends the growing conversation, so the run reads about 963,000 input tokens in total and writes about 18,000 output tokens.

Our arithmetic at published list prices, with the assumptions stated above. Cache-hit share is an assumption — measure yours from your provider dashboard. Competitor rates approximate, checked October 21, 2026.

Two conclusions, and the first one is uncomfortable. At list price, Mercury 3 is the most expensive model in its own comparison class — about $0.21 against $0.16 for MiniMax and DeepSeek off-peak and $0.11 for GPT-6 Luna or Claude Haiku 5.5. At the promotional price the same run is ~$0.10, which makes it the cheapest on the board. That is a 2× swing in unit economics hanging on a discount with no stated expiry. Budget at list; treat the discount as upside; and if the model only makes financial sense at $0.10, you are one announcement away from a cost review.

The second conclusion is that caching, not the headline, decides the bill. On the same 30 steps, 72% cache hits take Mercury 3 from $0.21 to $0.08 at list. The catch is that Mercury's cache rate is the weakest number in its card relative to rivals: $0.02 per million is 33% above MiniMax's $0.015 and about 3.3× to 6.7× DeepSeek's $0.003–$0.006. Only during the promotion, at $0.01, does Mercury's cache undercut MiniMax. If your agent loop lives on cache hits — and most do, because the system prompt and tool schema repeat every step — that line matters more than the input price everyone quotes.

One more number, because it is the reason to buy this model at all. Writing 18,000 output tokens takes about 17 seconds at 1,068 tokens/s, about 74 seconds at the 243 OpenRouter measured, and about 138 seconds at the ~130 the table assigns to GPT-6 Luna. Decode time is not the whole wall clock — prefill and tool latency are in there too — but on output-heavy work the gap is measured in minutes per hundred runs, and that is the commercial argument, not the benchmark table.

Is It Free?

Not as a product, but there is a real trial allowance and it is larger than most.

• 100 million free tokens per new API key. Confirmed on Inception's models page and in the launch post, and the pricing section frames it as a "Free" plan whose entire content is that allowance. This is a genuine pilot budget rather than a marketing page: at list rates it is worth roughly $20 if spent entirely on input and up to about $70 if spent entirely on output. It is one-time and tied to the key, so it is a comparison-run allowance, not a free tier.
• Mercury Chat is the other no-cost door. Inception links a chat surface from the launch post, which is the cheapest way to form your own opinion about whether the diffusion output reads differently from an autoregressive model's. Read the privacy terms before pasting anything you would not publish.
• The 50% launch price is a discount, not a free tier. $0.10 and $0.35 are real prices you pay, and the offer has no published end date — so it is neither free nor reliably permanent.
• There is no open-weights escape hatch. DeepSeek's MIT checkpoint lets you run a comparable model at zero marginal cost forever; MiniMax has at least promised weights later. Inception has published nothing, so the only zero-cost route is the trial grant and the chat app, not your own deployment.

Practical read: use the 100 million tokens to run your own traces against your incumbent, and budget the API at $0.20 / $0.70 for anything you plan to keep running. There is no configuration in which this model is both free and in production.

Pros & Cons

5 Best Inception Mercury 3 Alternatives

Comparison Table

Prices approximate, in US dollars, checked October 21, 2026. A dash means the figure is not published on a comparable current basis — not that it is zero. Mercury 3's promo prices are the launch discount with no announced end date; its speed column prints the vendor claim and the marketplace median because they differ by 4×. GPT-6 Luna and Claude Haiku 5.5 speed figures are Inception's, not the vendors' own.

Which One Should You Choose?

• Real-time voice, search, tutoring or support — start here. This is the workload the architecture was built for and the one where the evidence is strongest: IFBench +15 over Luna, τ³-bank Banking more than double Haiku, and partners already running it on voice, live search and web navigation. If time to first token is the constraint rather than decode throughput, price Mercury Voice at $0.40/$1.50 as well — under 170 ms TTFT is a different product from 1,068 tokens/s.
• High-volume classification and routing — buy Mercury Decide, not Mercury 3. $0.04 per million input, output billed at zero, on an endpoint built for typed decisions with calibrated probabilities. That is a tenth of Mercury 3's input price and it removes the output leg entirely, which no chat model in this table can match. If you need a general chat model for the same job, Mercury 3's instant reasoning level is the next cheapest thing — and unlike MiniMax it does not force a thinking block into every call.
• Long documents and repository work — pilot, then verify recall at depth. A 1M window at $0.20 per million is genuinely cheap, and filling it once costs about $0.20 before the model writes a word. But the only long-context evidence published is MRCR v2 at 75.50, behind Haiku 5.5's 78.40, and there is no needle test at 900K. Run your own retrieval check at the depth you actually need; if it holds, the price is excellent. If it does not, MiniMax M3.1 Flash has the same window cheaper and DeepSeek V4.1-Flash has a comparable one with cheaper caching.
• Tool-heavy agents with irreversible actions — do not standardise on it yet. Tool calling works and the endpoint is OpenAI-compatible, so the integration cost is an afternoon. But the vendor's own table has it 5.3 points behind Claude Haiku 5.5 on DeepSWE v1, and that benchmark is the closest public proxy for "hold exact state across many steps." Run 50–100 of your real traces first; if it holds up, you get the speed and the price. If it does not, no amount of IFBench makes up for an agent that mis-sequences a step.
• Self-hosting or air-gapped deployment — impossible, and not on a roadmap. No weights, no licence, no parameter count, no checkpoint. Compare DeepSeek V4.1-Flash under MIT at 510.3 GB needing one 8× H200 node, an open Qwen checkpoint if you want sizes that fit a workstation, or Kimi K3 if you have 1.56 TB of patience. Mercury 3 is a rental.
• Pure cost minimisation — the answer flips depending on the discount. At list, Mercury 3 loses to GPT-6 Luna, Claude Haiku 5.5, MiniMax and DeepSeek off-peak on our 30-step model. At the promotional price it wins outright at ~$0.10. Since the promotion has no published end date, the honest recommendation is to build on the model whose list price you can live with and treat Mercury as a promotional window in which to run your evaluation. Our LLM API cost guide covers the levers — caching, output caps, effort levels — that move a bill more than any headline rate.

Is Diffusion Actually Ready?

Mercury 3 is the first release where the answer is "for some workloads, yes," and it is worth being precise about which, because the marketing and the table point in different directions.

What has genuinely been demonstrated. Scaling a diffusion model 40× without losing throughput is a real result if it holds, and the mechanism is not mysterious: parallel refinement spends more compute per pass on a bigger model without lengthening the serial chain. Inception's claim that autoregressive scaling laws carry over to diffusion is the interesting scientific statement in the launch, and the operational proof is that a model this size is being sold at $0.20 per million input tokens with 1,068 tokens per second claimed. Nobody else is doing that. The company also deserves credit for publishing a table in which its model loses four rows — most launch posts would have shown the eight.

What has not been demonstrated. Three things, in ascending order of how much they should worry you.

• External evidence. There is none. Twelve rows, one vendor, medium effort, harnesses of its choosing, no paper, no model card, no independent rerun as of October 21, 2026. This is normal for a launch week and it is still the reason our score is 4.0 rather than 4.4.
• The shape of the losses. Mercury 3 loses agentic coding on DeepSWE v1 and long-context recall on MRCR v2 — the two categories where committing to a whole block early is most likely to cost you, and the two categories where the rest of the market has spent two years optimising sequential state. One benchmark is not proof of an architectural limit; two losses, in the two predicted places, inside the vendor's own table, is a pattern worth respecting.
• Operational maturity. No parameter count means no capacity planning. No GPU disclosure means the headline number cannot be reproduced. No temperature below 0.5 means no deterministic reruns. No published long-context evaluation means the 1M window is a number rather than a capability until you test it. No fine-tuning path, no batch API in the launch material, and no weight release — so the ecosystem that grew around every open model this year cannot grow around this one.

The fair verdict: diffusion is ready where latency is the product and exactness is not — voice agents, interactive tutoring, real-time search, support deflection, and the first pass of a browser agent that will retry anyway. It is not yet ready where a wrong step is expensive and unrecoverable: financial extraction, multi-step transactions, long tool chains with side effects. Mercury 3's own table says exactly that, which is more than most launches do.

Privacy & Data Note

Mercury 3 is API only, and there is no way around that, so the data question is a vendor question rather than a deployment question.

• No self-host escape route exists. With DeepSeek you can take MIT weights into your own VPC; with Mercury 3 there are no weights, no licence and no checkpoint size. The enterprise tier's "dedicated capacity, autoscaling, compliance controls and configurable data retention" is a better contract on Inception's infrastructure, not a way to keep data off it.
• Your prompts and completions leave your perimeter on every route. The Inception Platform, OpenRouter, Baseten and Vercel AI Gateway all terminate at Inception's model. Agent workloads are the worst case: a browser agent reads whatever it can log into, a support agent reads customer records. If your data classification forbids third-party inference, this model is out regardless of price.
• Read the actual documents rather than the launch post. Inception's terms of service and privacy policy are the instruments that govern retention, training use and subprocessors, and the launch post does not summarise them. We are not going to guess at their contents here — check them, and ask for a data-processing agreement before you build a pipeline, particularly if you operate under GDPR or handle regulated data. Enterprise buyers should treat "configurable data retention" as a question to ask sales, not an answer.
• Modalities reduce one risk and not the others. Mercury 3 is text only, so you are not uploading images by accident — but Mercury Decide accepts text, JSON and images on its own endpoint, so a "we only send text" policy has to cover the whole portfolio.

Two mitigations short of abandoning it: pass references instead of contents where your agent design allows, and treat the chat surface and the API as separate decisions with separate risk profiles — the chat app is a fine place to evaluate quality and a bad place to paste a client's contract.

Frequently Asked Questions