Mercury 3 vs Grok 4.7: Two Clocks, Not Two Models

Ask what Mercury 3 and Grok 4.7 have in common and the answer is a clock. Both are sold on how long a job takes, and they mean opposite things by it. Mercury 3, released by Inception on October 19, 2026, is built to answer in under a second: a diffusion model generating 1,068 tokens per second on NVIDIA GPUs, a 1M-token window, and four reasoning settings whose fastest rung is called "instant". Grok 4.7, released by SpaceXAI on September 21, 2026, is built to keep working: a 500,000-token window, a reasoning ladder that tops out at xhigh, and an independent measurement showing it burned roughly 240 million output tokens to complete the Artificial Analysis Intelligence Index at a cost of $3.74 per task. One model treats latency as the product. The other treats duration as the product. Comparing them on a single scoreline misses the only question that matters — which clock your workload is actually on. Both ends of a split policy can live behind one key, with automatic failover catching the slow lane. 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.

The two clocks, priced

Start with what the rate cards say, because the difference is large enough to change what you can build:

• Input — Mercury 3 $0.20 per 1M at list ($0.10 at launch) vs Grok 4.7 $2.00 per 1M

• Output — Mercury 3 $0.70 per 1M at list ($0.35 at launch) vs Grok 4.7 $6.00 per 1M

• Cached input — Mercury 3 $0.02 per 1M ($0.01 at launch) vs Grok 4.7 $0.50 per 1M

• Context — 1,000,000 tokens vs 500,000

• Maximum output in one response — 131,072 tokens vs no published vendor cap; our own card for grok-4.7 lists 450,000

• Input modality — text only vs text and images

• Reasoning settings — instant, low, medium, high vs low, medium, high, xhigh

• Throughput — 1,068 tokens per second, vendor-reported vs not published by the vendor

• Long-request repricing — none published vs every rate doubled above 200,000 input tokens, applied to the whole request

• Weights — closed on both

Read the output line alone and Mercury 3 looks like a rounding error next to Grok 4.7: $0.70 against $6.00, or $0.35 during the launch window. Read the cached line and the gap widens rather than narrows, because $0.02 against $0.50 is a factor of twenty-five regardless of the discount. That combination — cheap output and near-free cache reads — is what makes a high-frequency loop affordable, and it is the design target the model was clearly built for.

But the rate card is only half of a cost. Grok 4.7's own design assumption is that a hard problem deserves a long reasoning pass, and the independent board shows what that costs when the problem is hard enough: $3.74 per completed index task, against $0.72 for GPT-6.1 Sol and, on the same board, no Mercury 3 entry at all. Grok 4.7 spends tokens to think. Mercury 3 spends almost nothing per token and promises to think quickly. Those are not competing claims; they are competing budgets.

What a long reasoning pass actually buys

Grok 4.7 is not a fast model that got slower. It is a deliberate bet that multi-hour work — agentic coding loops, document-heavy analysis, professional deliverables — rewards a model that keeps going, and the independent results show that bet paying off in specific places rather than across the board.

• GDPval-AA, economically valuable knowledge work — Grok 4.7 Elo 1711.07, the second-highest of the models compared here and ahead of GPT-6.1 Sol's 1593.85

• SciCode — 0.5741, ahead of both GPT-6.1 Sol (0.5417) and Qwen3.8 Max (0.5208)

• HLE — 0.4314

• AA-LCR long-context reasoning — 0.7667

• Terminal-Bench 4.0 — 0.2576, the weakest number in its own column

• AutomationBench — 0.6556, the strongest of the four models in this series

• Intelligence Index — 46.4 at xhigh, per Artificial Analysis

• Cost per index task — $3.74

That profile — strong on knowledge work and automation, weak on terminal-style coding — is not the profile of a general-purpose flagship, and it is more useful to know than a rank. A team that runs long autonomous coding sessions and picks Grok 4.7 for them is picking it against its own measurements.

Mercury 3 has no comparable column. Inception's published evidence is different in kind: a 50-task Mind2Web navigation test in its own harness, where it completed 50% of tasks, plus partner testimonials from TinyFish AI, RevisionDojo, Octen AI and Lorikeet. It has no Artificial Analysis entry as of October 20, 2026, which means every capability claim in this piece about Mercury 3 beyond speed and price is vendor-reported and unreproduced. That is not a reason to dismiss it — a model nine days old with no independent score is a normal state, and early coverage is exactly what this blog exists to publish. It is a reason to keep the two columns labelled differently.

Three workloads, three answers

A support queue or a voice agent. Every millisecond is a customer waiting, and the model has to be cheap enough to run on every message. Mercury 3 wins this on the numbers as published: 1,068 tokens per second, $0.70 output at list, $0.02 cached input, an "instant" rung that skips reasoning entirely. Grok 4.7 can do this work, but at $6.00 output with a default reasoning pass it is paying for deliberation the conversation does not need. This is the case Inception built the model for, and the partner quotes are all from this shape of product.

A multi-hour coding or research agent. The job runs unattended, the transcript grows past a few hundred thousand tokens, and the model has to hold a plan across many steps. Here Grok 4.7's 500K window, xhigh reasoning and measured knowledge-work strength are the relevant features, and Mercury 3's 1M window is the relevant counter-argument: more room, far cheaper per token, but no evidence yet that it holds a plan across a long horizon. Note also that Grok 4.7 doubles every rate above 200,000 input tokens for the whole request, while Mercury 3 publishes no long-request surcharge. On a genuinely long transcript, the nominal 8.6× output gap can narrow to under 5× — and that is the regime where Mercury 3's lack of a benchmark starts to hurt, because the cost advantage arrives exactly where its capability is least proven.

Anything that has to read an image. Grok 4.7 takes images. Mercury 3's documentation lists text as its only supported format. This is not a pricing question and no amount of tokens per second answers it.

The reason to run both rather than pick

The split is unusually clean because the two models fail in different directions: Mercury 3 is cheap and unmeasured, Grok 4.7 is expensive and measured, and their modality and reasoning ranges barely overlap. That is the shape of a routing problem rather than a procurement decision.

Grok 4.7 is on OrcaRouter at SpaceXAI's list price with 0% markup, including the doubled above-200K rate, so the cost of trying a policy is the same as the cost of calling the vendor directly. Mercury 3 is not on the router; it is served through Inception's own API and several third-party platforms, and it is nine days old. A routing DSL earns its keep here in a way it rarely does: send instant-lane requests — short prompts, strict latency budgets, no images — to Mercury 3, keep everything that needs vision or xhigh reasoning on Grok 4.7, and let automatic failover catch the case where the new model's queue backs up. The policy is expressible; the evidence for it is what the next month of traffic will supply.

What to watch before you move budget

Two signals would change this comparison, and both are specific.

• A Mercury 3 entry on Artificial Analysis. One Intelligence Index score and one cost-per-task figure would tell you whether the cheap fast model is close enough to Grok 4.7 on knowledge work to justify routing real traffic. Without it, the 1,068 tokens per second is a throughput fact and not a capability claim

• Grok 4.7's token burn on your own workloads. The 240-million-token index run is a synthetic benchmark; a support queue and a coding agent burn very different volumes. Measure output tokens per completed task on one representative week before assuming the $6.00 rate sets your bill

What to ignore, meanwhile, is any comparison that puts the two models on one leaderboard column without noting that one of them has never been on the board. The interesting fact about Mercury 3 is not that it is fast — Inception has been shipping fast diffusion models for a year — but that it is fast with a 1M window at a price that makes per-request economics trivial. The interesting fact about Grok 4.7 is not that it tops a chart, because it does not; it is that it is the most automation-strong model in this set and pays for that with tokens. Those are different products, and the right number of them to run is probably not one.