Mercury 3 vs Claude Opus 5: The Same 1M-Token Window, Priced Two Different Ways

Both Mercury 3 and Claude Opus 5 will accept a million tokens in one call, and that is where the similarity stops being useful. Inception Labs released Mercury 3 on October 19, 2026 at $0.20 per million input tokens and $0.70 per million output, halved to $0.10 and $0.35 for a launch window with no published end date. Claude Opus 5, which A​nthropic shipped on July 24, 2026, charges $5.00 and $25.00 for the same two units with cached reads at $0.50 and cache writes at $10.00. On output that is a 71-fold gap at Mercury's launch price and a 36-fold gap at its list price — and yet the decision that actually faces anyone holding a long document is not which number is smaller. It is whether the document is text, and whether one pass over it has to be right. The documented AI failures and agent incidents behind releases like this one are collected in the OrcaRouter AI Incident Archive where each entry carries its own sources, severity, confidence grade and disputed flag.

Those two questions split the pair cleanly, because they are genuinely different products. Opus 5 takes text, images and files, is A​nthropic's most capable model in the Opus line, and is positioned at long-horizon agentic work — staying coherent across multi-step sessions with heavy tool use, with particular strength in end-to-end software engineering, code review and bug finding, and visual analysis. Mercury 3 is a diffusion language model that takes text and nothing else, produces tokens in blocks rather than one at a time, and runs at a vendor-measured 1,068 tokens per second against roughly 54 for Opus 5 on Artificial Analysis's harness.

What each one is, without the marketing layer

Mercury 3 is the third generation of Inception's bet that parallel decoding is the right architecture for the cheap end of the market. It denoises a block of positions at once and commits them together, which is where the throughput comes from. Inception reports that it is more than 40 times the total parameters of Mercury 1 and still runs at 1,000-plus tokens per second, that its context window grew from 260,000 to 1,000,000 tokens, and that it carries a 131,072-token output ceiling. None of those are independently verified.

• Price — Mercury 3: $0.20 / $0.70 per million, $0.10 / $0.35 at launch, cached input 90% below the input rate. Claude Opus 5: $5.00 / $25.00, cached reads $0.50, cache writes $10.00.

• Context and output — Mercury 3: 1,000,000 in, 131,072 out. Claude Opus 5: 1,000,000 in, 128,000 out.

• Modalities — Mercury 3: text in, text out. Claude Opus 5: text, image and file in, text out.

• Speed — Mercury 3: 1,068 tokens per second, Inception-measured on NVIDIA hardware. Claude Opus 5: about 54 tokens per second as measured by Artificial Analysis.

• Independent scores — Mercury 3: none, no Artificial Analysis page exists. Claude Opus 5: 50.8 on the Artificial Analysis Intelligence Index and 78.0 on its coding index, second of 138 models on that coding board.

• Reasoning effort — Mercury 3: instant, low, medium and high, defaulting to low. Claude Opus 5: A​nthropic's effort and thinking-budget controls on the same API surface.

The context windows matching is the coincidence that makes the comparison worth writing, and the way each model is priced around them is where they diverge. Opus 5 charges for cache writes at $10.00 per million — twice its input rate — and then charges $0.50 for reads, so the economics of a long-document workload depend heavily on whether you send the same preamble once or fifty times. Mercury 3 has no published write premium and prices cached input at $0.02 at list, $0.01 during the launch window, which makes a repeated 300,000-token document almost free on the second call and every call after.

The document question, run through both rate cards

Take a realistic long-document workload: a 250-page contract set, 180,000 input tokens, a 2,000-token structured summary out. Ten thousand documents a month, single pass each, no caching.

• Claude Opus 5 — 180,000 input tokens at $5.00 per million is $0.90 per document; 2,000 output tokens at $25.00 is $0.05. Call it $0.95 each, $9,500 for the month.

• Mercury 3 at list — $0.036 of input and $0.0014 of output, about $0.037 each, $374 for the month.

• Mercury 3 at launch price — about $0.019 each, $188 for the month.

That is a 25-fold difference at list and a 50-fold one during the discount, and the shape of it is entirely the input rate: the summary is 1% of the tokens and 5% of Opus 5's per-document cost. Now the same corpus with the document re-sent five times, as a multi-step extraction loop would.

• Claude Opus 5 — the first call writes the cache at $10.00 per million for 180,000 tokens, $1.80, then four reads at $0.50 per million, $0.09 each. Input lands at $2.16 per document plus $0.25 of output across five calls: about $2.41, $24,100 for the month.

• Mercury 3 — every call is billed as input at $0.20, or cached at 90% off. Five passes at the list input rate is $0.18; with the document cached after the first pass it is about $0.06 all in. Either way the month is under $2,000, and the first pass is most of it.

The caching structure inverts nothing but it changes the ratio, and it changes it in Opus 5's favour: the $10.00 write premium is a one-time cost that amortises across every read. What does not change is the floor. At 180,000 tokens per document there is no caching strategy that brings a $5.00 input rate within an order of magnitude of a $0.20 one.

Where Opus 5's price is buying something you cannot get elsewhere in this pair

The arithmetic above assumes the document is text. Half of the documents in a real contract set are not: they are scanned pages, signature blocks photographed on a phone, engineering drawings, charts embedded as images. Mercury 3 cannot read any of them. Opus 5 can, and its visual analysis is one of the three strengths A​nthropic names in the model's positioning, alongside software engineering and code review.

That is not a minor caveat to a cost comparison. It is the comparison. A model that cannot see the scanned appendix has to be fed OCR output, and OCR output on a signature page or a stamped amendment is where document pipelines quietly fail — a dropped clause, a misread date, a table flattened into a guess. The $0.037-per-document figure for Mercury 3 is real, and it is the price of processing the part of the corpus that was already machine-readable.

The second thing Opus 5's price buys is the one nobody can quantify yet. It has a measured position on a neutral harness: 50.8 on the intelligence index, 78.0 on coding, second of 138 models there. Mercury 3 has a single quality result, and it is Inception's own — 50% completion on 50 live Mind2Web navigation tasks inside Inception's production agent harness, which the company describes as "significantly more than GPT-6.1-Sol" at the same token volume and step count. That is a serious piece of evidence and an uncontrolled one: the harness, the target sites and the scoring all belong to the seller, and no third party has repeated it.

So the honest framing of the quality gap is not "Opus 5 is better". It is "Opus 5 is measured and Mercury 3 is not", and those are different claims with different risk profiles. A measured model's failure modes are documented somewhere. An unmeasured one's are discovered by you, in production, at whatever volume you sent it.

What a routing layer does with an unmeasured model

Claude Opus 5 is on the OrcaRouter catalogue at A​nthropic's own rates — $5.00 and $25.00 per million, $0.50 cached reads, $10.00 cache writes — behind the same OpenAI-compatible endpoint as everything else we route, with no markup added on top. Mercury 3 is not on the catalogue; our model API returns nothing for any Inception model, so anyone calling it goes to Inception's platform directly, where new accounts get 100 million free tokens, or to one of the several third-party platforms that host it.

That asymmetry is exactly the case the routing layer exists for, and the useful pattern is not a coin flip between two models. It is a rule that makes the cheap path conditional. Text-only documents below a token threshold go to Mercury 3. Anything with an image, anything above the threshold, anything that comes back with a low-confidence structure goes to Opus 5. Both sit behind one key, the rule is configuration rather than application code, and the split can be moved — from 10% of traffic to 90%, or back to zero — without a deploy.

The same rule handles the thing that will actually change. Inception's launch discount has no published end date, and when it ends Mercury 3's output price doubles. A neutral intelligence score for Mercury 3 will appear at some point, and it may be better or worse than the vendor's framing. Neither event requires anyone to rewrite an integration if the model sits behind a routing rule; both require it if the model sits in the application.

There is one more honest note about the price gap, and it cuts against the arithmetic above. Opus 5's price is a published list price that has been stable since July, with a documented cache structure and a documented context ceiling. Mercury 3's cheapest number is a promotion. Cost models built on promotions have a habit of becoming wrong on a date nobody wrote down, which is why every figure in this article was run at both the launch price and the list price rather than only the attractive one.

Who should pick which

If the corpus is text, the answers are short, and a downstream check catches the failures — classification, extraction, re-ranking, summarisation of already-clean documents — Mercury 3's rate card is an order-of-magnitude saving and the absence of a neutral score is a manageable risk. You will know your own error rate within a day of traffic, and the cost of those errors at $0.037 a document is measured in cents.

If the corpus has images in it, if the session runs for hours with tools in the loop, or if a wrong answer costs more than the tokens that produced it, Opus 5 is the model whose behaviour is documented and whose price is stable. It is also, at 78.0 on the coding index, one of the two best coding models on the board — the cheapest option is not in that conversation at all.

The one workflow that should not be built on either without a rule in front of it is the one most teams actually have: a mixed queue, where 80% of the documents are clean text and 20% are scans. Sending all of it to Opus 5 pays flagship rates for OCR-grade work. Sending all of it to Mercury 3 silently loses the scans. The routing rule is not a nice-to-have in that queue; it is the difference between a working pipeline and an expensive one that is wrong 20% of the time.