A US startup that brings the idea behind diffusion models — familiar from image generation — into text generation. While a typical LLM emits tokens one at a time in sequence, Inception’s “Mercury” series refines an entire response from a coarse state, which allows tokens to be produced in parallel. The company reports over 1,000 tokens per second on commercially available NVIDIA GPUs and a time to first token of under 300 milliseconds. Practically speaking, the API is OpenAI-compatible, so you can try it by swapping the endpoint and model name in an existing application.
Key Features
- Parallel generation with a diffusion LLM (dLLM): Unlike autoregressive models that generate one token at a time from left to right, the output is refined iteratively as a whole. The company reports 5–7x higher throughput and up to 70% lower cost per task compared with conventional models
- Mercury 2 — the flagship reasoning model: Supports a 128K token context along with reasoning, tool use, and structured output. Reasoning depth can be set to instant / low / medium / high, so you can trade speed against accuracy per use case
- Mercury Edit 2 — a lightweight model for code editing: A smaller 32K context, aimed at latency-sensitive work such as code completion and inline edits where wait time shapes the experience
- Drop-in via an OpenAI-compatible API: Works with the standard OpenAI client as well as major libraries including LangChain, LiteLLM, AISuite, and the Vercel AI SDK
- Available through major clouds: In addition to Inception’s own platform, the models are offered on AWS Bedrock and Azure AI Foundry, making them easier to fit into existing cloud contracts and access controls
- Optimized for real-time use: The main targets are voice agents, customer support, in-editor completion, and running many search queries per request — cases where per-request latency directly becomes experience quality
Pricing
| Plan | Price | What you get |
|---|---|---|
| Free | $0 | A free token allowance with access to all models |
| Developer | Usage-based | Generous rate limits, priority support |
| Enterprise | Contact sales | Custom rate limits, SLA, security and privacy requirements, volume pricing |
Usage-based rates by model (per 1 million tokens):
| Model | Input | Cached input | Output | Context |
|---|---|---|---|---|
| Mercury 2 | $0.25 | $0.025 | $0.75 | 128K |
| Mercury Edit 2 | $0.25 | $0.025 | $0.75 | 32K |
Pricing is current as of August 2026. Check the official site for the latest rates. The size of the free token allowance is stated differently on the website and in the documentation, so confirm the actual amount when you sign up.
Pros & Cons
✅ Pros
- Responses start coming back quickly, which matters most in voice conversations and editor completion where any perceived wait is fatal
- At $0.25 input and $0.75 output per million tokens, unit pricing sits below many high-performance models
- Cached input costs a tenth of standard input, which suits agent workloads that resend the same preamble repeatedly
- OpenAI compatibility keeps code changes minimal and makes side-by-side evaluation straightforward
- Availability on AWS Bedrock and Azure AI Foundry makes it easier to adopt within corporate cloud procurement rules
⚠️ Cons
- Diffusion LLMs are still new, and there is less shared knowledge about which tasks they handle poorly than for autoregressive models
- The model lineup is small, and multimodal options such as image or audio input are limited today
- This is a developer-facing API rather than an end-user chat app, so it is not designed for non-engineers to use on its own
- Official material and community examples in languages other than English are scarce
Comparison with Similar Services
| Item | Inception (Mercury) | Groq | Cerebras Inference | Google Gemini Flash |
|---|---|---|---|---|
| How speed is achieved | Model architecture (diffusion, parallel generation) | Custom chip (LPU) | Custom chip (Wafer Scale Engine) | Model efficiency and optimization |
| Models offered | In-house Mercury series | Mostly open-weight models | Mostly open-weight models | In-house Gemini series |
| API compatibility | OpenAI-compatible | OpenAI-compatible | OpenAI-compatible | Native plus an OpenAI-compatible mode |
| Major cloud availability | AWS Bedrock / Azure AI Foundry | Mainly first-party | Mainly first-party | Google Cloud (Vertex AI) |
| Free tier | Yes | Yes | Yes | Yes |
Several services market fast inference, but Groq and Cerebras run autoregressive models faster on custom hardware, whereas Inception changes how generation itself works. That is a fundamental difference in approach.
Who Is It For
- Developers building voice agents or real-time conversation where response latency is the bottleneck
- Teams shipping in-editor completion or inline editing, where perceived speed is part of the quality
- Anyone running agents that call an LLM many times per request and wants to cut latency and cost together
- Engineers who want to swap the inference backend behind an OpenAI-compatible interface and A/B test speed and cost
- Companies that want a fast inference option inside an existing AWS or Azure agreement
Summary
Inception is one of the few players attacking LLM generation speed from a different direction: the diffusion model. Figures such as over 1,000 tokens per second and sub-300ms time to first token may be hard to feel in a chat window, but for voice agents, editor completion, and multi-step agent pipelines they can change the design itself. With an OpenAI-compatible API and a free allowance, a good starting point is to swap the model name in an existing app and check whether accuracy holds up on your own tasks.