Mercury 3 by Inception: A Hands-On Test of the Diffusion Language Model
Mercury 3 from Inception Labs tested on reasoning, factual recall, multilingual tasks, and agentic coding via API. Here's how it performs.
What is Mercury 3 and why does it matter?
Mercury 3 is the latest diffusion-based language model from Inception, built on a fundamentally different generation process than most LLMs on the market. Instead of producing text one token at a time from left to right, Mercury refines a full block of tokens in parallel, similar to how image diffusion models turn noise into a finished picture over several passes. Inception says Mercury 3 is roughly 40 times larger than its original Mercury model, runs at around 1,068 tokens per second on GPUs, and supports a 1 million token context window. The company also claims it outperforms GPT-5 Nano and Claude Haiku 4.5 on its internal benchmarks. It matters because diffusion language models have mostly been a research curiosity. Mercury 3 is one of the first attempts to make the approach practical at scale, with real API access and agentic tool use.
TL;DR
- Parallel token generation is the core idea behind Mercury 3: rather than writing text sequentially, it drafts and refines a block of tokens at once, which is the architectural reason for its speed advantage.
- Inception claims big scale and throughput gains, putting Mercury 3 at roughly 40 times the size of the original Mercury model and around 1,068 tokens per second on GPU inference, with a 1 million token context window.
- Short reasoning tasks are where it shines: in testing, Mercury 3 solved a classic object-permanence puzzle (a marble under a flipped cup moved into a microwave) correctly and quickly, with minimal visible “thinking” steps.
- Factual recall held up, correctly attributing a commonly misattributed quote to Upton Sinclair without getting tripped up by the popular false attribution.
- Multilingual instruction following was strong across a long list of languages, generating brand names in each one while preserving format, though many outputs leaned on literal translations of “spring” rather than truly creative naming.
- Agentic coding and long-horizon tasks exposed real weaknesses: when asked to debug a multi-file web app or build a complex interactive SVG tattoo simulator, the model slowed down noticeably and occasionally looped before recovering.
- The debugging test on a donor-registry compliance app was solved correctly, with Mercury 3 identifying and fixing a subtle UI/logic mismatch without any explicit error messages to go on.
One coffee. One working app.
You bring the idea. Remy manages the project.
How does a diffusion language model actually work?
Traditional large language models are autoregressive: they predict the next token based on everything generated so far, one word (or sub-word) at a time, left to right. That’s reliable but inherently sequential, which caps how much parallelism you can squeeze out of the hardware during generation.
Diffusion language models flip this. They start with a noisy or masked version of the output and iteratively refine the whole sequence in parallel steps, the same general principle behind image diffusion models like Stable Diffusion, just applied to text tokens instead of pixels. Because the model isn’t forced to commit to one token before moving to the next, it can update multiple parts of the response simultaneously across refinement passes. That’s the architectural reason Inception points to for Mercury’s speed advantage: generation throughput isn’t bottlenecked by strict token-by-token dependency.
In practice, during testing, this showed up as visibly short “thinking” traces on simpler tasks. The model would barely pause before snapping to a grounded, correct answer, rather than working through a long visible chain of reasoning the way many autoregressive reasoning models do.
How fast and accurate is Mercury 3 on reasoning tasks?
On a classic physical-reasoning test, the kind designed to catch models that pattern-match instead of actually tracking object state, Mercury 3 performed well. The test posed a simple scenario: a marble sits on a table, a cup is flipped over it, and the cup (with the marble presumably inside) is carried to a microwave. The model correctly identified that the marble stays on the table, since flipping a cup over an object doesn’t move the object with the cup, then explained the reasoning using physical concepts like inertia and the possibility of suction or the cup’s rim catching the marble. The answer came quickly, with minimal visible deliberation, suggesting Mercury 3 handled the causal logic in very few generation passes.
Factual recall was similarly solid. Given a well-known quote that’s frequently misattributed in casual usage, Mercury 3 correctly named Upton Sinclair as the source rather than defaulting to the more popular (and wrong) attribution that trips up many models.
Is Mercury 3 good at multilingual and instruction-following tasks?
Tested with a prompt asking for an eco-friendly water bottle brand name in a long list of languages, Mercury 3 covered every language on the list and kept the requested language-name formatting consistent throughout, which is a meaningful instruction-following detail that’s easy for models to drop in long, repetitive multilingual tasks.
Creatively, the results were mixed. Many entries centered on a “spring” or “pure water” theme, which gave the set a coherent, designed feel rather than random noise, but a lot of individual names ended up reading as straightforward translations of “spring” rather than true brand names. A few entries stood out as genuinely inventive, including “Wellspring,” “Aqua Viva,” and a invented-sounding name like “Gluggle.” The model also flagged less common languages or dialects as best-effort guesses needing a native speaker’s verification, an honest signal rather than false confidence.
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
How does Mercury 3 handle agentic coding and debugging?
The most demanding test involved a fictional real-world style application: a donor family registry tracking birth counts against a policy compliance limit. A subtle bug existed in the app: no crashes, no error messages, just a mismatch between the displayed compliance dial and the underlying data (a donor with 40 births across five clinics showing as compliant when it should have flagged a limit breach). Mercury 3, running through an API-connected coding agent, was given a high-level goal to find and fix the issue.
It succeeded, correctly identifying the donors over the family limit and fixing the compliance logic so the dashboard reflected the real data, all without an explicit error trace to follow. That’s a meaningful test of grounded reasoning over a real codebase rather than simple pattern completion.
A second, more open-ended coding task asked the model to build a self-contained file simulating an interactive Japanese-style dragon tattoo on a leg, with specific visual and interactive requirements. This is where the diffusion approach showed its current limits. The model took considerably longer, appeared to loop on certain steps before correcting course, and struggled more with tool calling as the task grew longer and more complex. It did eventually produce a working, interactive single-file result with controls that functioned (adjustable line length, a black-and-white toggle), but the visual output was rough: the dragon looked more like a thin serpentine sketch than a detailed, scaled creature, and the leg shape was a plain outline rather than anatomically realistic. The structural and functional requirements of the brief were met; the artistic polish was not, which is expected given Mercury 3 is a language model, not an image generator.
Is Mercury 3 worth using right now?
For short, well-defined tasks, factual lookups, logical reasoning puzzles, multilingual instruction following, Mercury 3 performed quickly and accurately in testing, and its speed advantage from parallel token generation is genuinely noticeable. For agentic debugging against a real (if small) codebase, it also held up, correctly diagnosing a non-obvious bug with no error output to lean on.
Where it struggled was long-horizon, complex generation, the kind of task that requires sustained tool use and many sequential decisions. That’s arguably the current frontier of diffusion language models generally: the parallel refinement that makes short tasks fast doesn’t automatically scale cleanly to long, intricate, multi-step generation. It isn’t a frontier-level model across the board, but for its speed class and as a diffusion-based alternative to standard autoregressive models, it’s a notable step up from Inception’s earlier Mercury releases.
Frequently Asked Questions
What makes Mercury 3 different from models like GPT or Claude?
Mercury 3 uses a diffusion-based generation process instead of the standard autoregressive, token-by-token approach. It refines a block of output in parallel over multiple passes rather than writing strictly left to right, which is the main source of its speed advantage.
How fast is Mercury 3 compared to other language models?
Inception states Mercury 3 runs at around 1,068 tokens per second on GPUs. Combined with its parallel generation approach, this gives it noticeably quick response times on shorter, well-scoped tasks, based on testing.
Does Mercury 3 support a large context window?
Yes. Inception lists a 1 million token context window for Mercury 3, which allows it to handle long documents or extended agentic sessions without losing earlier context.
How does Mercury 3 perform on coding tasks?
It performed well on a debugging task involving a real-world style app with a subtle, non-obvious bug, correctly identifying and fixing the issue. On longer, more open-ended generation tasks, such as building a complex interactive graphic from scratch, it slowed down and occasionally looped before completing the task successfully.
Is Mercury 3 better than GPT or Claude models?
Inception claims Mercury 3 beats GPT-5 Nano and Claude Haiku 4.5 on its benchmarks, though those are smaller, lower-cost models rather than frontier flagships. Hands-on testing suggests Mercury 3 is strong on speed, reasoning, and instruction following, with more variable results on long, complex generation tasks.
