Last month I watched a demo of an AI sales agent make 30 browser clicks to fill out a quote form. It worked. It also took almost two minutes, with the cursor spinning the whole time. The founder in the room leaned over and said, “Yeah, it works. It just… feels dead while you wait.”
That feeling — dead air while a model thinks — is the hidden tax on almost every AI product shipping right now. And it’s exactly the tax Mercury 3, announced October 19, 2026 by Redwood City’s Inception Labs, is trying to kill.
Real talk: model launches are a dime a dozen in 2026. I don’t write about most of them. But Mercury 3 is different because it’s not playing the same game. Instead of pushing one token out at a time like every autoregressive model you’ve ever used, it’s a diffusion LLM — it generates many tokens in parallel, refining a rough draft the way image models sharpen noise into a picture. The headline number: 1,068 tokens per second on NVIDIA GPUs. That’s not a typo. That’s roughly the speed at which you read this sentence, delivered back to you as text.
So. Is this the model your startup should be building on? I dug through the launch materials, the benchmarks (with appropriate skepticism — more on that), the pricing page, and the developer docs. Here’s the whole picture, founder to founder.
What Mercury 3 Actually Is (and What “Diffusion LLM” Means)
Quick history, because it matters: Mercury 3 is Inception Labs’ fourth release. Mercury 1 arrived in June 2025 as the first real commercial diffusion LLM. Mercury 2 added reasoning. Mercury 2.5 brought tunable reasoning and a 260K-token context window. Now Mercury 3 is, per Inception, “the most capable diffusion LLM ever released” and more than 40x larger than Mercury 1.
The company was co-founded by Stefano Ermon, Volodymyr Kuleshov, and Aditya Grover — people who have been working on diffusion models since before it was fashionable. This isn’t a pivot. It’s a thesis they’ve been building on for years.
Here’s the plain-English version of how it works. A normal LLM — GPT-style, Claude-style — writes the way you type: one token after another, left to right, each word depending on the ones before it. It’s careful, and it’s slow. You literally cannot parallelize it, because word #5 needs word #4 to exist first.
A diffusion LLM starts with a rough, mostly-wrong draft of the whole response at once, then refines everything together over several passes — coarse to fine. Masked tokens get filled in in parallel. Think of it less like typing and more like developing a photograph: the whole image comes into focus together.
The payoff is structural, not a trick. Parallel generation means the model can be 4-8x faster than speed-optimized rivals (Inception’s claim) without the usual “we made it faster by making it dumber” trade-off. That’s the whole bet. And honestly? It’s a bet I find pretty convincing on first principles. The autoregressive bottleneck was always an engineering constraint, not a law of nature.
The Speed Story: 1,068 Tokens Per Second
Let’s put 1,068 tokens per second in concrete terms. A typical chat reply is maybe 150-300 tokens — Mercury 3 would finish it in a quarter of a second. A 2,000-token code review? Under two seconds. Long agent loops, the thing that makes AI products feel dead? They shrink from minutes to seconds.
Now the honest caveats, because I refuse to just print the press release:
- It’s Inception’s own measurement. 1,068 tok/s was measured by Inception on NVIDIA GPUs. They haven’t said which GPU. Real-world throughput on your workload, your batch size, your context length will differ. Treat it as a ceiling, not a promise.
- The “4-8x faster” claim is versus “speed-optimized rivals.” That’s a specific peer group — small fast models, distilled models, the kind you’d actually race against. It’s not claiming to be 8x faster than every frontier model.
- Speed on a benchmark harness isn’t speed in your app. TTFT (time to first token), network latency, and your tool-call overhead all eat into generation speed. The model can only fix the generation part.
Still. Even if you haircut the number by a third, you’re left with something that fundamentally changes what an agent-heavy product feels like. And feeling matters — it matters a lot. Nobody reopens an app that makes them wait.
Benchmarks: The Honest Read
Okay, benchmarks. Here’s where I put my skeptic hat on, because every vendor table is a marketing document wearing a lab coat. Inception tested Mercury 3 at medium settings and reports it leads GPT-6 Luna and Claude Haiku 5.5 on 8 of 12 evaluations. Specific claimed wins:
- SWE-Bench Atlas: 51.08 — real-world software engineering tasks
- BrowseComp+: 55.18 (vs GPT-6 Luna 50.50, Claude Haiku 5.5 45.78) — deep web research
- IFBench: 76.84 — instruction following
- GPQA Diamond and DeepSearchQA
And the losses, which Inception also published — credit where it’s due:
- DeepSWE v1: 46.31 vs Claude Haiku 5.5’s 51.62 — Haiku wins software engineering here
- MRCR v2 — a multi-round context retrieval eval, lost
- One long-context evaluation vs GPT-6 Luna — lost
Inception frames this as a new “Pareto frontier in speed and intelligence” — the first time you haven’t had to choose between the two. The data they published supports the frontier framing at least directionally: leading on two-thirds of tests while being dramatically faster is a real combination, even if you don’t take every number at face value.
My take: read the vendor table as a directional signal, not gospel. What it tells me is that Mercury 3 is a legitimate mid-frontier model — competitive with the fast tier of GPT-6 Luna and Haiku 5.5 (I’ve covered both: see my GPT-6 Luna guide and my Claude Haiku 5.5 guide) — while being much faster. It does not tell me Mercury 3 beats them at everything. It loses on some things. That’s fine. What would be suspicious is a table with zero losses.
Two more things worth knowing: Inception hasn’t disclosed the parameter count, and Mercury 3 is API-only — no open weights. If your product needs self-hosting or fine-tuning access to weights, that’s a hard stop.
Pricing: A Real Launch Discount, With a Catch to Watch
This is the part founders actually care about, so let’s be precise. From Inception’s official models page, Mercury 3’s launch pricing is 50% off standard rates:
- Launch: $0.10 per 1M input tokens, $0.35 per 1M output tokens, $0.01 cached input
- Standard (after discount ends): $0.20 in / $0.70 out, $0.02 cached
- Free tier: 100M tokens for new accounts — genuinely enough to build and test a real prototype
Two siblings launched alongside it: Mercury Voice (a speech model with time-to-first-token under 170ms, launching at $0.20 in / $0.75 out) and Mercury Decide (a decision/classification model at $0.02 in, $0 out — practically free for routing and classification work). If your agent stack needs a cheap classifier deciding which tool to call, Decide at two cents per million is worth a look.
The catch to watch: Inception hasn’t published an end date for the 50% discount. That means the launch price is great for prototyping now, but you should model your unit economics at the standard $0.20/$0.70 rates. Anything cheaper is a bonus, not a plan. I say this because I’ve watched founders build pricing around launch discounts before — don’t. Run the numbers on the real rates (my guide to pricing an AI SaaS product walks through the margin math), and if you’re sweating API costs generally, my piece on cutting your AI API bill has tactics that apply regardless of which model you pick.
Also worth noting: Mercury 2 and 2.5 are being retired for new users. If you’re somehow still on an older Mercury model, migration isn’t optional — plan for it.
Building on Mercury 3: The Developer Experience
Here’s the genuinely nice part: it’s an OpenAI-compatible API. You swap the base URL, set the model string to mercury-3, and your existing code mostly just works. Tool calling works. Structured outputs work through JSON schema in response_format. There’s a reasoning_effort parameter carried over from Mercury 2.5’s tunable reasoning, so you can dial thinking up for hard tasks and down for fast ones.
A minimal example looks like this:
from openai import OpenAI client = OpenAI( base_url="https://api.inceptionlabs.ai/v1", api_key="your-api-key", ) resp = client.chat.completions.create( model="mercury-3", messages=[{"role": "user", "content": "Summarize this support ticket."}], extra_body={"reasoning_effort": "medium"}, ) print(resp.choices[0].message.content)Availability is decent for a day-one launch: Inception’s own API Platform, plus OpenRouter, Baseten, and Vercel. The OpenRouter listing specifically flags Mercury 3 as suited for agentic workflows and real-time apps — search agents, voice pipelines, coding subagents. And the early customer stories line up: teams running browser-use agents, interactive education products, real-time search agents, and customer support agents (Lorikeet is cited for support). That’s a coherent pattern. It’s not “great at everything” — it’s great where latency is the product.
One practical note for founders planning a build: picking the model is maybe 30% of shipping an AI product. The integration work — the API layer, the frontend, the tool wiring, the latency budget across your whole stack — is where launches get won or lost. If that part isn’t your team’s strength, bringing in a web development studio like AISquadX that already does AI integration work can save you months of learning the hard way.
Where Mercury 3 Makes Sense for Startups
Let me be specific about the product shapes where I’d actually reach for this:
- Real-time voice and support agents. Mercury Voice’s sub-170ms time-to-first-token plus a fast text backbone means conversations that don’t have that awful pause. Support is the obvious wedge — Lorikeet is already there.
- Browser-use and coding subagents. Long agent loops are where 1,068 tok/s compounds. Ten steps at 2 seconds each beats ten steps at 20 seconds each by a margin your users will feel in their bones.
- Live search and research agents. BrowseComp+ at 55.18 (claimed) plus a 1M-token context window is a strong combo for deep-research products that need to read a lot and answer fast.
- Interactive education. Tutoring products live or die on flow. A tutor that answers before the student loses the thread is a different product than one that makes them wait.
Notice the thread: every one of these is a product where latency IS the experience. If your product is “generate a 5,000-word report overnight,” Mercury 3’s speed buys you almost nothing — reach for the smartest model instead. If your product is “answer before the user blinks,” this is your shortlist.
Where It Doesn’t (Yet)
Balance, because no launch is perfect:
- It loses some benchmarks. DeepSWE v1 goes to Haiku 5.5, MRCR v2 and a long-context eval go elsewhere. If your workload looks like those evals — heavy multi-round retrieval, certain software engineering shapes — test before you commit.
- No open weights. API-only, parameter count undisclosed. Self-hosters and fine-tuners, look elsewhere.
- Diffusion is still new territory. The ecosystem — evals, fine-tuning recipes, the accumulated folk knowledge of the autoregressive world — is thinner. You’ll be doing more of your own validation. Early, but not bleeding-edge: this is a fourth-generation product.
- The discount has no end date. Great now; model your margins on standard pricing.
None of these are disqualifiers. They’re the normal shape of a strong, opinionated new model. You just go in with eyes open.
FAQ
What is Mercury 3?
Mercury 3 is Inception Labs’ fourth-generation diffusion large language model, announced October 19, 2026. Unlike autoregressive models that generate one token at a time, it generates multiple tokens in parallel through coarse-to-fine refinement, reaching a claimed 1,068 tokens per second on NVIDIA GPUs.
How much does Mercury 3 cost?
Launch pricing is 50% off: $0.10 per million input tokens and $0.35 per million output tokens, with cached input at $0.01. Standard rates are $0.20/$0.70, and new accounts get 100M free tokens. No end date for the discount has been published.
Is Mercury 3 better than GPT-6 Luna or Claude Haiku 5.5?
On Inception’s own vendor-reported benchmarks at medium settings, Mercury 3 leads both on 8 of 12 tests — including SWE-Bench Atlas (51.08) and BrowseComp+ (55.18). It loses DeepSWE v1 to Haiku 5.5 and a long-context eval to Luna. Treat vendor numbers as directional, and benchmark on your own workload before switching.
How do I use the Mercury 3 API?
It’s OpenAI-compatible: point your client at Inception’s API endpoint, use the model string mercury-3, and your existing code largely works. It supports tool calling, structured outputs via JSON schema, and a reasoning_effort parameter. It’s also available through OpenRouter, Baseten, and Vercel.
What should startups build with Mercury 3?
Products where latency is the experience: real-time voice and support agents, browser-use agents, coding subagents, live search agents, and interactive education. If your product generates long content asynchronously, speed matters less and a frontier reasoning model may serve you better.
The Bottom Line
Mercury 3 is the most interesting model launch I’ve seen in a while, and not because of any single benchmark number. It’s interesting because it attacks a real constraint — generation latency — at the architectural level instead of papering over it with distillation or smaller models.
The honest summary: a legitimately fast, genuinely competitive mid-frontier model with aggressive launch pricing and a clean developer experience, from a team that has been doing exactly this for years. Vendor benchmarks need independent confirmation, the discount clock is ticking silently, and there’s no open-weights option. But if you’re building anything where the user waits on the model — voice, agents, live search — Mercury 3 deserves a serious test drive this week, not someday.
The 100M free tokens mean the test costs you nothing but an afternoon. That’s the part I like best. Go find out if the speed is real on your workload. Then decide.
