Mercury 2.5

1. Diffusion generation is very fast

Mercury 2.5’s main technical difference is how it generates text.

An autoregressive model has to produce token N before moving to token N+1. Mercury can work on multiple positions at once instead of following that strict sequence.

Inception reports 1,107 tokens per second, with first-token latency below 300 ms.

OpenCall gives a more concrete example. After adopting the model, its P99 latency fell from several minutes to about 1 second, while P50 dropped from 0.4 seconds to under 0.2.

That difference gets more noticeable when one task triggers many model calls in a row.

2. Tool calling and structured JSON

Mercury 2.5 supports parallel tool calls and schema-compliant JSON output.

A search agent, for example, can launch several queries at once and pass the results downstream in a predictable format.

Reasoning effort is adjustable too. Lower settings can be used for simple work, with more compute reserved for harder requests.

3. The context window doubled

Mercury 2 had a 128K context window. Mercury 2.5 raises that to 260K, with a 66K-token maximum output.

That gives it room for long documents, large collections of search results, or a substantial amount of source code.

The larger window tells us how much it can accept, not how reliably it can use every part of a very long prompt. Those are different problems.

4. What changed from Mercury 2

Mercury 2 launched in February 2026 with a reported speed of about 1,009 tokens per second.

Mercury 2.5 moves that to 1,107, doubles the context window from 128K to 260K, and, according to Inception, improves overall intelligence by about 40%. The company also reports gains in coding, instruction following, and math.

The speed increase from 1,009 to 1,107 is fairly modest. Doubling the context window is the bigger change on paper.

Coding is where I’d be more careful.

In one third-party test covering 40 coding tasks, 28 passed completely. In 11 cases, the task had failed but the model still reported that it was finished.

That failure mode matters. Bad code can often be caught by a test suite. A model that wrongly decides the job is complete can push an automated workflow forward when it should have stopped.

Mercury 2.5 makes a strong case for workloads built from lots of small model calls. Search steps, tool calls, JSON formatting, voice interactions — this is where its speed can change how responsive the whole system feels.

I’m less comfortable with it as an autonomous coding model.

The concern isn’t that it occasionally writes bad code; every model does. It’s that third-party testing found cases where the work had failed and Mercury still thought it was done.

For an agent pipeline, I’d test it. For a model expected to take a repository, make a complicated change, verify the result, and tell me when it’s safe to ship, I’d want stronger evidence first.