Mercury 3 Launches at 1,000+ Tokens/Sec. How Fast Is That?

Illustration of an AI data stream forming sentences in parallel

Have you ever told a coding agent "fix this bug and run the tests too" and then waited? The model answers a few lines quickly, but the wait grows long while it reads files, makes a plan, and calls tools several times.

However, Inception announced on October 19 that its newly released Mercury 3 generates 1,068 tokens per second. On numbers alone that's a speed that overwhelms most models, but how fast is it really?

✦ Generation Speed Compared

Tokens per second, per Inception's official comparison table (not an independent measurement)

1,068Mercury 3 (tokens/s)
~240Claude Haiku 5.5 (tokens/s)
~130GPT-6 Luna (tokens/s)

Let's start with the comparison numbers. In the official comparison table from Inception Labs, which made Mercury 3, GPT-6 Luna is listed at about 130 tokens per second and Claude Haiku 5.5 at about 240. Mercury 3 in the same table is 1,068 tokens.

By the numbers alone that's about 8 times GPT-6 Luna and about 4.5 times Haiku 5.5. Of course, remember that this is a comparison presented by the company that made Mercury. Not every request on the actual API always comes out at this speed.

It Differs Right from How Sentences Are Made

Language models like GPT and Claude, when making an answer, generate one token, then make the next token based on that result, and repeat. The structure is such that the next token can only be made once the previous token is out.

The longer the answer, the more these steps pile up and the heavier the burden gets.

✦ Two Ways of Producing Tokens

Sequential vs diffusion generation

Sequential generation
Generate one token, then generate the next token from that result, and repeat
Diffusion generation
Make several parts of a text block in parallel, then refine them again

Mercury 3 applies a diffusion method, similar to image generation AI, to text.

Just as an image diffusion model, instead of drawing a finished picture from the start, tidies up noise over multiple steps, a diffusion language model makes several parts of a text block in parallel and refines them again.

It doesn't mean the whole answer is finished in a single flash. The point is that it can predict and revise several tokens together, so it can cut the waiting time of writing one token at a time in order.

Do you know the speed-reading method of "don't look at words or sentences; look at the whole text at a glance like taking a photo"?

When we start reading a very long text one character at a time, perfectly, it takes a long time and we gradually forget what we read earlier.

But if you look down at the whole text with a big view to get the skeleton, then skim mainly the important words afterward, you end up reading faster and remembering it longer.

It's slightly different from the diffusion method, but if you're not sure what diffusion is, understanding it this way might help a little.

This approach offers interesting possibilities for code too. Sometimes while editing the lower part of a code file, you have to change a variable or function higher up.

Unlike a sequential generation model that can't take back tokens it has already sent out, a diffusion model can refine other parts inside the block in the next step. Then it could use tokens a bit more flexibly and efficiently.

〈Official Inception Mercury 2.5 demo: diffusion generating text in parallel〉
* From the official Inception channel.

A 1M-Token Context, and a Launch Discount on Price

Mercury 3 raised the context length it can handle as input and context in one request to 1 million tokens. That's bigger than the previous Mercury 2.5's 260,000 tokens.

✦ Mercury 3 API Prices

Per million tokens, in dollars

List price
• Input: $0.20
• Output: $0.70
Launch discount (currently announced)
• Input: $0.10
• Output: $0.35

The price also stands out. The official list price is $0.20 per million input tokens and $0.70 for output, but with the launch discount the currently announced prices are $0.10 and $0.35 respectively. Cache-hit input is priced 90% lower than the input rate.

(The end date of the discount isn't stated anywhere.) There's also an announcement that new accounts get 100 million free tokens, so if you're interested, try it right now.

It can be used not only on the Inception API but also on OpenRouter, Baseten, and Vercel, and since it supports the OpenAI API-compatible format, it's also a plus that you can try it without changing your existing connection code much.

※ P.S. In November 2026, Inception announced that the Mercury API will remain available through December 28 and then shut down. Mercury models also stopped being available on OpenRouter on November 8.

But Does Real Work Hit 1,000 Tokens/Sec Too?

✦ Why the Speed Numbers Differ

Different measurement conditions, so not a direct comparison

✔ 1,068 tokens/s: Announced by Inception, on NVIDIA GPUs
✔ 198 tokens/s: Bito test, median generation speed per request
✔ 512 tokens/s: Bito test, peak per request

But here's the thing. Bito released its own coding test results on October 20, and Mercury 3's real per-request generation speed in a coding agent had a median of 198 tokens per second, with a peak of 512 tokens.

It's still fast, but there's a big gap from the 1,068 tokens the company announced. That's because the test environment and the actual inference environment are different.

A coding agent reads code and conversation history, decides its next action, waits for tool execution, and then calls the model again.

Just because the part where the model generates new tokens speeds up to 1,000 tokens per second doesn't mean the whole task runs at 1,000 tokens per second.

✦ Long Coding Session Time

Bito's own test, average per session (minutes)

5.8Mercury 3
6.8Claude Sonnet 5.5
8.1Claude Haiku 5.5
15.4DeepSeek V4.1 Flash-1017
17.2Claude Opus 5.5

Anyway, in Bito's long multi-step coding session test, Mercury 3 finished the job fastest at an average of 5.8 minutes. Claude Sonnet 5.5 took 6.8 minutes, DeepSeek V4.1 Flash-1017 took 15.4 minutes, and Claude Opus 5.5 took 17.2 minutes.

On processing time alone, Mercury 3 is definitely attractive.

✦ Long Coding Session Scores

Bito's own test, score (%)

87%Claude Opus 5.5
77%DeepSeek V4.1 Flash-1017
77%Claude Sonnet 5.5
76%Claude Haiku 5.5
65%Mercury 3

But the test scores were different. In the long session test, Mercury 3's score stopped at 65%, while DeepSeek and Sonnet got 77% each, Haiku 76%, and Opus 87%.

In the test of asking a single short coding question too, Mercury 3 scored 76%, lower than DeepSeek's 90% and Haiku's 79%.

In other words, the ability to produce an answer quickly and the ability to solve a complex problem accurately to the end have to be looked at separately.

Honestly, personally... if a model scores lower than 'my little dimwit' Haiku 5.5, I'd never want to talk to that model. I think the stress would pile up and make me lose my hair. Ehehe♡

✦ Long Coding Session Cost

Bito's own test, cost per session (dollars)

✔ DeepSeek V4.1 Flash-1017: $0.14
✔ Mercury 3: $0.48
✔ Claude Haiku 5.5: $0.69
✔ Claude Sonnet 5.5: $1.28
✔ Claude Opus 5.5: $5.42

Cost per task also came out differently from the token price list. The long coding session cost Bito measured was $0.48 for Mercury 3 and $0.14 for DeepSeek.

Even if the price per token is cheap, if the agent keeps sending the same conversation history and the cache doesn't hit often enough, the actual bill can grow.

This result is a self-run evaluation Bito did with 8 long sessions and 16 short sessions, so it doesn't set an absolute ranking of the models overall, but compared with Mercury 3, it seems certain that existing models like DeepSeek use tokens more efficiently.

〈A hands-on test of Mercury 3's announced speed in practice〉
* From the Codedigipt YouTube channel.

So Where Is Mercury 3 Worth Using?

In places where getting answers fast matters, like short and clearly scoped requests, real-time search, customer inquiries, and conversational tutors, Mercury 3's strengths can come alive.

For example, in a service where a user browsing a website asks a question and needs to see an answer within seconds, frustration grows the longer the wait gets.

Even in agents that call the model many times, if each response gets faster, the time users wait can shrink.

Conversely, for handing over a complex coding job whole, or work that requires planning multiple steps and carefully checking results, you have to weigh quality as much as speed. Mercury 3 drops down the list.

So Mercury 3 is better seen not as a model that will replace every GPT or Claude, but as a case showing that language models can get faster in another way too.

Just bringing the diffusion approach of image generation into text generation and showing practical speed is interesting in itself. But it shouldn't end with marveling at the number 1,068.

What readers feel isn't the token count but how fast they get a proper answer when they ask a question.

If you use ChatGPT or Claude, you know how dim (?) the Luna and Haiku models can be. Every time I hand work to the Luna or Haiku model and it handles it sloppily, I feel how poor I am. (If I were rich, I'd use Astra or Fable as much as I liked.)

Benchmarks and evaluation scores aren't everything, but for users fed up with the slightly scatterbrained (?) answers of lightweight models like GPT Luna, Claude Haiku, and Gemini Flash Lite, Mercury 3's charm will be a bit less.

Going by the scores, it's somewhat in that family too. On the other hand, it will definitely help users who need to handle agent work at very high speed.

That's all for this post. See you next time.

Related posts

No comments:

No comments yet. Want to leave the first one?