Mercury 3 vs Qwen3.8-Max: The Cheap Token and the Expensive Answer

Qwen3.8-Max and Mercury 3 are the two poles of a pricing argument that most model comparisons get backwards. On the rate card, Mercury 3 costs $0.10 per million input tokens and $0.35 per million output during its launch window, against $2.00 and $6.00 for Qwen3.8-Max. That looks like a seventeen-fold discount on generation. Then Artificial Analysis measures what each model actually spends to complete a task, and Qwen3.8-Max comes in at $5.41 per Intelligence Index evaluation while its per-token price is moderate — because it generated 190M tokens to get there, against a median of 85M. Mercury 3, released by Inception Labs on October 19, 2026, has no equivalent measurement at all. 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.

So the useful question is not which model is cheaper per token. It is which one is cheaper per finished job, and neither vendor's launch page answers it. Here is what the evidence does support, and what you have to measure yourself.

What Qwen3.8-Max is, in the version you would actually call

Qwen3.8-Max is A​libaba's flagship: a sparse mixture-of-experts model with 2.4 trillion total parameters and 95 billion active per token, natively multimodal — text, images and video in, text out — with a 1M-token context on the hosted API and a 131,072-token output ceiling. It has been generally available since August 3, 2026, and the independent record is no longer thin.

• Intelligence Index — 45 on Artificial Analysis Index v4.3.2, ranked 33rd of 217 models on the page's current snapshot.

• Output speed — 39.6 tokens per second, ranked 183rd of 186. The page's own summary calls it "notably slow."

• Cost per index task — $5.41, in the most expensive quartile of the models it lists.

• Verbosity — 190M output tokens across the index run, described as "very verbose" against a median of 85M.

• Context — measured at 984k on the endpoint, which is the practical ceiling of the advertised million rather than a different specification.

That combination is internally consistent and worth stating plainly: Qwen3.8-Max is a strong-reasoning, slow, talkative model. It is good at the thing it is priced to do and expensive at the margin because it takes many steps to do it. The $5.41 per task is not a pricing error. It is the model's behaviour showing up on the bill.

A note on versions, because it will bite anyone comparing pages. The independent measurements above are against the September 2 snapshot, listed as "Qwen3.8 Max (0902)". A​libaba also serves an undated qwen/qwen3.8-max endpoint at the same $2/$6 with a $0.25 cached-input rate; both resolve in our catalogue, and pinning the dated snapshot is the right move for anything you intend to reproduce.

What Mercury 3 gives you, and what it withholds

Inception's model is a diffusion language model that generates tokens in parallel, and every number in the launch post is about speed, size or price rather than quality.

• Throughput — 1,068 tokens per second, attributed to "NVIDIA GPUs" with no hardware named, no batch size, and no statement of which of the four reasoning-effort settings produced it.

• Context — 1M tokens, up from 260K on Mercury 2.5, with a 131,072-token output ceiling.

• Price — $0.20 input and $0.70 output per million at list, halved to $0.10 and $0.35 during the launch window. Cached input is $0.02 at list, $0.01 in the window.

• Effort — four settings: instant, low, medium, high. The default is low, where Mercury 2.5 and Mercury 2 defaulted to medium.

• Modalities — text in, text out. No vision, no audio.

• Quality — no numeric benchmark. The claim is that it "outperforms GPT-6 Luna and Claude Haiku 5.5", with no margin and no benchmark named. The only structured result is 50% completion on 50 live Mind2Web navigation tasks in Inception's own harness.

That default effort setting is the detail most likely to poison a comparison. A model answering at low effort will be faster and score lower than the same model at high, and Inception's own comparisons do not say which setting they used. If you benchmark Mercury 3 without pinning the parameter, your numbers are not comparable to anyone else's — including Inception's.

Test one: cost per finished job, not per token

Take a support-triage agent that processes 2 million input tokens and 300,000 output tokens a day. On Mercury 3 at list that is $0.40 of input and $0.21 of output, or $0.61 a day. On Qwen3.8-Max at $2/$6 it is $4.00 and $1.80, or $5.80 a day. Roughly a tenfold gap, and at the launch rate Mercury's side drops to about $0.31.

Now the correction that matters. Those figures assume one pass per task. Qwen3.8-Max's measured 64 steps per GDPval-AA task, against 14 for its predecessor, is the exact mechanism that turns a $6 output rate into $5.41 per evaluation. If Mercury 3 needs two attempts where Q​wen needs one, Mercury's effective cost doubles and some of the gap closes. If Mercury needs four attempts, most of it does. The cost comparison is therefore downstream of a completion-rate question that nobody has measured, which is why the token-rate table is the least useful thing on either vendor's page.

For the input side there is a lever worth knowing about. Qwen3.8-Max charges $0.25 per million cached input tokens; Mercury 3 charges $0.02, or $0.01 during launch. Agents resend the same system prompt and tool definitions on every step, so a 20,000-token preamble costs $0.0004 per call at Mercury's cached rate against $0.005 at Q​wen's. On a fifty-step run that is two cents versus twenty-five. Neither model's headline price reflects that, and for agent workloads it is the number that decides the budget.

Test two: what a slow model costs when a person is waiting

Speed is where the two models are not in the same category at all, and it is worth being precise about what each measurement means.

Mercury's 1,068 tokens per second is a vendor figure with no independent reproduction. What we do have from Artificial Analysis is the previous generation: Mercury 2.5 measured at roughly 706 tokens per second under its own harness, which is lower than the vendor number that accompanied that launch. That gap is the normal vendor-to-independent discount in this category, not evidence of bad faith — but it is the discount to apply mentally to 1,068 until someone reproduces it.

Qwen3.8-Max's 39.6 tokens per second is independently measured and comes with a rank: 183rd of 186. At that rate a 1,500-token answer takes about 38 seconds of generation alone, before prefill. For a background agent that reports back, that is fine. For anything where a human watches the cursor, it is disqualifying on its own, whatever the quality.

That is the fault line this comparison actually rests on. Mercury 3's speed is unverified but plausible given the architecture, and its price is genuinely low. Qwen3.8-Max's speed is verified and poor, and its price is genuinely high. Neither of those facts tells you which model writes a better answer, and for most teams the answer-quality question is the one they cannot yet settle.

Test three: give each model the job it is shaped for

The two models fail in opposite directions, which makes a side-by-side evaluation more informative than a single ranking.

Give Qwen3.8-Max the long, multimodal, high-stakes end. A 400-page filing, a screen recording of a broken checkout flow, a chart that has to be read correctly. It is the only one of the two that can accept the input at all, and it has an independent score to set expectations against. Budget for the verbosity: with reasoning on, output tokens are billed at $6 per million and there will be more of them than you expect. The instruction-following gap is the thing to test first — Q​wen's own published table put IFBench as its weakest number, and the independent cost-per-task figure is a direct consequence of it exceeding scope.

Give Mercury 3 the short, text-only, latency-critical end where a wrong answer is cheap to catch. Autocomplete, query rewriting, a first-pass classification, a hint in a tutoring flow. Pin the effort setting. Set a retry budget. Treat every quality claim as a hypothesis, because that is what it currently is.

And do not give either model a job that depends on the other's strength. Qwen3.8-Max cannot be made fast by asking politely; Mercury 3 cannot read a PDF page. Choosing between them on aggregate benchmark position is choosing the wrong variable.

Where OrcaRouter sits in this, which is on one side only

Qwen3.8-Max is on our catalogue as qwen/qwen3.8-max, at the provider's list price with 0% markup passed through — so if A​libaba moves the rate, the change is live here the same day rather than at the next billing cycle. It sits behind the same OpenAI-compatible endpoint as everything else we serve, which means an evaluation is a model-string change and a production trial is a traffic percentage, not a migration.

Mercury 3 is not on our catalogue. Our model API returns nothing for any Inception model, so the route to it is Inception's own platform, which hands new accounts 100 million free tokens. We route the Q​wen side and we do not route the Mercury side, and the asymmetry in how you reach each one follows from that rather than from a preference.

The practical use of the routing layer is that the evaluation can be blind and cheap. Send one slice of traffic to qwen/qwen3.8-max, keep the incumbent on another, and compare cost per completed task rather than cost per token — which, as the numbers above show, are not the same measurement and can point in opposite directions. Automatic failover across providers means a bad week at one endpoint becomes a routing decision rather than an incident, and the routing DSL lets you hold the split as a rule so closing the experiment is a configuration change.

What would settle it, and what to do until then

Three measurements would end this argument. An Artificial Analysis page for Mercury 3, which would put both models on one harness and replace a vendor sentence with a number. A published completion rate for Mercury 3 on a coding or agentic benchmark, which would convert the token discount into a per-job cost. And a Qwen3.8-Max latency measurement under your own concurrency, because 39.6 tokens per second is an index figure, not a serving guarantee, and a model that is merely slow in a benchmark can be unusable under load.

Until those exist, the defensible position is narrower than either launch post implies. Qwen3.8-Max is a measured, multimodal, slow, expensive model that you can price with confidence and that will not surprise you on input formats. Mercury 3 is a cheap, fast, text-only model whose quality is unknown and whose speed figure is unreproduced. Buy Qwen3.8-Max for work you will not read before it ships. Try Mercury 3 for work where a person is waiting and a retry is free — and pin the effort setting, or you will be comparing your low-effort run against someone else's high.