Inception has launched Mercury 3, a diffusion-based large language model (LLM) designed to deliver fast responses for AI agents, voice assistants, search applications and other real-time tools. Announced on October 19, 2026, Mercury 3 claims generation speeds of 1,068 tokens per second on NVIDIA GPUs and supports a context window of one million tokens. Inception says the model delivers competitive results against speed-focused alternatives while generating text four to eight times faster.
The release highlights an alternative to the sequential text-generation approach used by most mainstream language models. Instead of predicting one token after another, diffusion language models generate and refine multiple parts of a response in parallel. Inception is positioning Mercury 3 for applications where delays accumulate across repeated model calls, including browser agents, interactive education, customer support and real-time search. The model is available through Inception’s API platform and selected third-party providers, with discounted launch pricing for developers.
Key Takeaways
- New model: Inception launched Mercury 3 on October 19, 2026.
- Reported speed: The company reports throughput of 1,068 tokens per second on NVIDIA GPUs.
- Long context: Mercury 3 supports a one-million-token context window, up from 260,000 tokens in Mercury 2.5.
- Diffusion architecture: The model generates and refines text in parallel rather than producing every token sequentially.
- Benchmark claims: Inception says Mercury 3 competes with or outperforms speed-focused models such as GPT-6 Luna and Claude Haiku 5.5 on several tests.
- Launch pricing: Discounted rates are $0.10 per million input tokens and $0.35 per million output tokens.
- Availability: Developers can access the model through Inception’s API and selected platforms, including OpenRouter, Baseten and Vercel.
What Is Mercury 3?
Mercury 3 is the latest major model in Inception’s Mercury family of diffusion language models. The company is developing an alternative to the autoregressive architecture used by most widely deployed chatbots and coding assistants.
In a conventional autoregressive model, text is generated one token at a time. Each new token depends on the tokens already produced, creating a sequential process that can make long answers take time to complete.
Diffusion language models approach generation differently. They begin with a partially masked or incomplete representation of the response and progressively refine it over multiple steps. Rather than waiting for every token to be generated in order, the model can work on several portions of the response together.
Inception argues that this approach can substantially increase generation speed while retaining useful language and reasoning capabilities. Mercury 3 is its latest attempt to demonstrate that diffusion models can scale beyond smaller, experimental systems into production applications.
The company says Mercury 3 is more than 40 times larger than its first Mercury model, while maintaining generation speeds above 1,000 tokens per second. It also reports that overall benchmark quality has improved substantially across the Mercury model family.
These are company-reported claims. The actual performance developers experience will depend on the workload, serving infrastructure, output length, model settings and measurement method.
How Diffusion Language Models Generate Text
The key difference between diffusion and conventional language models is how they construct a response.
| Feature | Diffusion language model | Autoregressive language model |
|---|---|---|
| Text generation | Iteratively refines multiple parts of a response | Predicts tokens sequentially |
| Main performance goal | Reduce generation latency through parallel refinement | Generate coherent text through next-token prediction |
| Potential advantage | High output throughput | Mature architecture with broad deployment |
| Important consideration | Quality and speed depend on refinement and serving methods | Longer outputs can require many sequential generation steps |
| Example in this release | Mercury 3 | Most conventional chatbot models |
Diffusion language generation is conceptually related to the process used by image diffusion systems, which progressively refine an image from noise. Text models use different representations and training methods, but the underlying idea of iterative refinement is similar.
The architecture does not mean that every part of an answer is produced instantaneously. The model still performs multiple computational steps, and the process of understanding the prompt, running tools and returning results can contribute to total response time.
For developers, the important question is whether the architecture delivers a meaningful improvement on the tasks they actually run. High token throughput can be especially useful when an application needs to generate many short responses or repeatedly call a model during an agent workflow.
Mercury 3 Reports Speeds Above 1,000 Tokens per Second
Inception reports that Mercury 3 reaches 1,068 tokens per second on NVIDIA GPUs. The company says this makes the model four to eight times faster than certain speed-optimised alternatives while delivering competitive benchmark performance.
The number refers to reported generation throughput, not a guarantee that every user will receive a complete answer at that speed. Real-world performance depends on hardware, provider capacity, request size, queueing, reasoning settings and the time required before the first token appears.
For a developer building a conversational application, both throughput and latency matter. Throughput measures how quickly tokens are generated, while latency describes how long a user waits for a response. A model can generate text quickly once generation begins but still experience delays from request processing or other stages.
This distinction is particularly important for voice assistants and browser agents. Users notice pauses during conversations, while an autonomous agent may make dozens of model calls before completing a task. Reducing the delay at each step can improve the overall experience.
Mercury 3 is intended to address that problem by combining high generation throughput with a model that can handle more complex tasks than its earlier versions.
A One-Million-Token Context Window
Mercury 3 supports a context window of one million tokens, a significant increase from the 260,000-token context window reported for Mercury 2.5.
A context window determines how much input and conversation history a model can process within a request, subject to the system’s implementation and token limits. A larger window can help a model work with extensive documents, codebases, research material and accumulated agent history without requiring everything to be divided into smaller pieces.
For example, a research assistant might need to examine multiple long reports before answering a question. A coding agent could benefit from access to a larger portion of a repository, while a browser agent may need to preserve information collected across many pages.
The one-million-token figure does not mean that every request must use that much context, nor does it guarantee perfect recall of every detail. Performance can vary depending on where relevant information appears, how the prompt is structured and the complexity of the task.
Large context windows can also increase processing costs when requests include substantial amounts of text. Developers will need to balance context size against latency, accuracy and token usage.
Nevertheless, the expansion gives Mercury 3 more flexibility for workflows involving large documents and repeated interactions.
Benchmark Claims Against GPT-6 Luna and Claude Haiku 5.5
Inception says Mercury 3 outperforms speed-focused competitors such as GPT-6 Luna and Claude Haiku 5.5 across a range of benchmarks. A report by MarkTechPost said the model led on eight of 12 tests in the company’s benchmark comparison.
The reported results include performance on software engineering and reasoning-related evaluations. For instance, MarkTechPost reported a score of 51.08 on SWE-Bench Atlas and 46.31 on DeepSWE v1. The latter result was below the reported 51.62 score for Claude Haiku 5.5 on that test.
These results illustrate why benchmark claims need to be read test by test. A model can perform well across a selection of evaluations while trailing competitors on particular tasks.
| Benchmark consideration | Why it matters |
|---|---|
| Coding performance | Helps assess the model’s ability to solve software engineering tasks |
| Reasoning evaluations | Test performance on problems requiring analysis and multi-step thinking |
| Generation throughput | Measures how quickly the model produces output |
| Test settings | Differences in effort levels, prompts and tools can affect comparisons |
| Independent replication | Helps determine whether results generalise beyond the developer’s tests |
The available comparisons should be treated as preliminary evidence rather than a definitive ranking of all AI models. Inception’s results are vendor-reported, and a fair comparison requires matching model settings, hardware, prompts, tool access and evaluation procedures.
For developers, the practical approach is to test Mercury 3 against the models they already use. A model that performs well on a general benchmark may still be less effective on a specific production workload.
Pricing and How Developers Can Access Mercury 3
Inception lists Mercury 3 at $0.20 per million input tokens and $0.70 per million output tokens. At launch, the company is offering a 50% discount, bringing the prices to $0.10 per million input tokens and $0.35 per million output tokens.
| Pricing component | Standard price | Launch price |
|---|---|---|
| Input tokens per million | $0.20 | $0.10 |
| Output tokens per million | $0.70 | $0.35 |
| Cached input tokens per million | $0.02 | $0.01 |
Prices are based on Inception’s published launch information and may change under its commercial terms.
The difference between input and output pricing matters because AI applications often process large amounts of source material before producing a relatively short answer. Other applications generate long responses or make repeated calls, so their costs can be distributed differently.
Mercury 3 is available through Inception’s API platform and selected providers, including OpenRouter, Baseten and Vercel. Inception says the model supports an OpenAI-compatible API, allowing developers to integrate it into existing applications with fewer changes.
The company is also offering 100 million free tokens to new API users under its launch programme. Developers should check the provider’s current terms, availability, rate limits and pricing before deploying the model in production.
Where Mercury 3 Could Be Useful
Inception is targeting workloads in which model latency directly affects the user experience or the total time required to complete a task.
Real-time search and browser agents
A browser agent may need to inspect a page, decide what to do next, click an element, collect information and repeat the process. Every step can involve another model call.
If each call becomes faster, the agent may complete its workflow more quickly. Mercury 3’s long context window may also help it retain information from multiple pages, although the model’s actual success rate will depend on its tool-use capabilities and the quality of its instructions.
Voice assistants and customer support
Voice applications require rapid responses to maintain a natural conversational rhythm. A slow answer can make a voice assistant feel unresponsive, even if the final response is accurate.
High generation throughput could help developers reduce delays in spoken interactions and customer support systems. However, end-to-end voice latency also depends on speech recognition, audio processing, tool calls and speech synthesis.
Coding and data engineering
Coding agents frequently read code, propose changes, execute tests and revise their output. A fast model can reduce the waiting time between iterations and make interactive development more responsive.
Mercury 3’s reported benchmark performance suggests it may be worth testing for software engineering tasks. Developers should still evaluate code correctness, debugging ability, security and performance on their own repositories before relying on it.
Interactive education
An AI tutor needs to respond quickly enough to keep a student engaged. Mercury 3 could support applications that generate hints, explanations and follow-up questions with lower waiting times.
The model’s usefulness in education will depend on more than speed. Accuracy, age-appropriate explanations and the ability to identify misconceptions remain important.
What Mercury 3 Does Not Prove Yet
Mercury 3 is an important development in diffusion language modelling, but its launch does not establish that diffusion models will replace conventional LLMs.
The reported speed figure is a vendor measurement, and actual throughput may differ across deployment environments. The benchmark results also come with limitations because they do not cover every kind of reasoning, coding or agent task.
Another question is how diffusion models behave under heavy production loads and very long contexts. Developers need to evaluate reliability, first-token latency, output quality, tool-calling behaviour and cost under realistic traffic.
There is also a distinction between an open API and open model weights. Mercury 3’s availability through APIs does not, by itself, mean developers can download and run the model weights independently. Organisations with strict deployment or data-control requirements should confirm the model’s hosting options and contractual terms.
These questions will determine where Mercury 3 fits in production systems. It may be a strong option for latency-sensitive workloads without being the best choice for every application.
The Bigger Picture
Mercury 3 represents another attempt to improve AI performance by changing the generation architecture rather than relying only on larger models or more computing power. Its reported combination of high throughput, a one-million-token context window and competitive benchmark results could make it attractive for applications where repeated model calls create delays.
The broader significance will depend on how these claims hold up in independent testing and real-world deployment. AI developers increasingly need to balance output quality, speed, context size and cost. Diffusion models offer a different way to approach that trade-off, but they will need to demonstrate consistent reliability across workloads before their role in the industry becomes clear.
Looking Ahead
Developers can begin evaluating Mercury 3 through Inception’s API and supported provider platforms. The most useful tests will compare it with existing models on representative tasks, measuring end-to-end latency, task completion rates, accuracy, token usage and operational cost. Such testing will help determine whether the reported throughput translates into a meaningful improvement in production.
The next stage for diffusion language models will be demonstrating that their speed advantage can scale alongside capability and reliability. If Mercury 3 performs well beyond curated benchmarks, it could encourage more developers to use diffusion-based systems for real-time applications. If gaps emerge on complex tasks or under production constraints, conventional autoregressive models are likely to remain important alternatives.
Frequently Asked Questions
1. What is Mercury 3?
Mercury 3 is a diffusion-based large language model developed by Inception. It is designed for fast text generation and applications such as AI agents, voice assistants, search and coding tools.
2. How fast is Mercury 3?
Inception reports generation throughput of 1,068 tokens per second on NVIDIA GPUs. Actual speeds can vary by hardware, provider, request and workload.
3. What is Mercury 3’s context window?
The model supports a context window of one million tokens, up from the 260,000-token window reported for Mercury 2.5.
4. How is a diffusion LLM different from a conventional LLM?
A conventional autoregressive LLM generates tokens sequentially. A diffusion LLM progressively refines multiple parts of a response in parallel, which can improve generation throughput.
5. How much does Mercury 3 cost?
Inception lists standard pricing at $0.20 per million input tokens and $0.70 per million output tokens. Its launch offer reduces these rates to $0.10 and $0.35, respectively.
6. Is Mercury 3 open source?
Its availability through an API does not mean its model weights are open. Developers should check Inception’s official documentation for the current licensing and deployment options.
7. Can Mercury 3 replace other AI models?
Not necessarily. Its speed and context window may make it useful for certain workloads, but developers should compare its accuracy, reliability, tool use and cost against alternatives before making a decision.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
