There’s a quiet shift happening in the sub-$5/M token tier of fast reasoning models.
In the past, most choices were based on quality, with cost only becoming a factor for massive quantities. OpenClaw, a local open-source agentic platform released in January 2026 by Pete Steinberger, created a paradigm shift that has led even individuals to looking for ways to optimize token cost. (Because we all want to be claws up running a bajillion agents, amirite?!)
Now, we're suddenly looking at our daily/weekly/monthly token shape.
And token shape, how much you cache, how much you generate, how long you iterate, determines whether GPT-5 mini, Mercury 2, or Claude 4.5 Haiku is the rational economic decision.
Below is a practical framework for choosing the right production-scale fast reasoning model when you care about latency, quality, and token spend. Some tasks absolutely require the latest-greatest-bleeding-edge-of-innovation frontier model, but most do not.
If all you want is an answer, see below. If you want to better understand the hows and whys of the calculations I've made, scroll down a bit farther. We break this down across multiple scenarios to show where 3 different models win, lose or draw: GPT-5 mini, Mercury 2, and Claude Haiku 4.5.
TL;DR: When to Choose Each
Choose GPT-5 mini if:
- You reuse long prompts constantly (heavy cache hits)
- Outputs are short (classification, QA validation, JSON verdicts)
- You want the lowest possible cost for “read a lot, write a little”
Choose Mercury 2 if:
- You generate substantial output per request (summaries, drafting, reasoning steps)
- Cache reuse is low or inconsistent
- Latency compounds across agent loops
- You want strong reasoning + 5x throughput (~1009 tokens/sec)
Choose Claude 4.5 Haiku if:
- You need Claude-specific behavior, style, or policy characteristics
- Output quality traits outweigh raw cost efficiency
- You can amortize cache writes across many cache hits
If you're purely optimizing for cost efficiency at scale, Haiku is rarely the winner.
The Pricing Landscape
ModelBase InputCached InputOutputNotable Trait
GPT-5 mini
- $0.25 / M input
- $0.025 / M cached input
- $2.00 / M output
- Extremely cheap cached reads
Mercury 2
- $0.25 / M input
- $0.025 / M cached input
- $0.75 / M output
- Very cheap output + 1,009 tok/sec
Claude 4.5 Haiku
- $1.00 / M
- $0.10 / M (hit)
- $5.00 / M
- Premium output cost
The critical difference:
- GPT-5 mini makes cached input almost free.
- Mercury makes output cheap.
- Claude makes neither especially cheap.
Now let’s pressure test them.
Scenario 1: High-Volume Classification & QA
Use case:
Agent validation, rubric scoring, content classification, safety checks.
Token shape (daily):
3M cached
750K fresh input
250K output
4M total
This is classic “OpenClaw” validator architecture:
Long shared system prompt. Tiny outputs. Tons of reuse.
Daily Cost
GPT-5 mini
Cached: 3M × $0.025 = $0.075
Input: 0.75M × $0.25 = $0.1875
Output: 0.25M × $2.00 = $0.50
= $0.7625/day
Mercury 2
Cached: 3M × $0.025 = $0.075
Input: 0.75M × $0.25 = $0.1875
Output: 0.25M × $0.75 = $0.1875
= $0.45/day
Claude Haiku
Cached: 3M × $0.10 = $0.30
Input: 0.75M × $1.00 = $0.75
Output: 0.25M × $5.00 = $1.25
= $2.30/day
Winner: Mercury 2
Now that Mercury matches GPT-5 mini’s cache pricing, its cheaper output ($0.75 vs $2.00) makes it decisively cheaper, even in low-output validator workflows.
This is a major shift. GPT-5 mini no longer wins the “read a lot, write a little” scenario on cost alone.
Scenario 2: Generation-Heavy Summaries
Use case:
- Multi-paragraph news summaries
- Rewrite tasks
- Reasoned analysis
- Agent planning outputs
Let’s assume:
- 1M cached
- 1M fresh input
- 1M output
- 3M total
Now output volume matters.
Daily Cost
GPT-5 mini
Cached: 1M × $0.025 = $0.025
Input: 1M × $0.25 = $0.25
Output: 1M × $2.00 = $2.00
= $2.275/day
Mercury 2
Cached: 1M × $0.025 = $0.025
Input: 1M × $0.25 = $0.25
Output: 1M × $0.75 = $0.75
= $1.025/day
Claude Haiku
Cached: 1M × $0.10 = $0.10
Input: 1M × $1.00 = $1.00
Output: 1M × $5.00 = $5.00
= $6.10/day
Winner: Mercury 2
With equal cache pricing, Mercury dominates once output volume becomes meaningful. It’s less than half the cost of GPT-5 mini in this scenario.
And this is before factoring in speed.
Mercury benchmarked at ~1009 tokens/sec.
GPT-5 mini sits around ~71 tokens/sec.
Claude Haiku ~89 tokens/sec.
If you're iterating in real-time workflows, that throughput difference compounds.
Scenario 3: Agent Loops (Latency Compounds)
Use case:
- Multi-step tool calls
- Browser automation
- Code agents
- Back-office automation
Assume:
- 2M cached
- 2M input
- 2M output
- 6M total
Now both input and output are substantial.
Daily Cost
GPT-5 mini
Cached: 2M × $0.025 = $0.05
Input: 2M × $0.25 = $0.50
Output: 2M × $2.00 = $4.00
= $4.55/day
Mercury 2
Cached: 2M × $0.025 = $0.05
Input: 2M × $0.25 = $0.50
Output: 2M × $0.75 = $1.50
= $2.05/day
Claude Haiku
Cached: 2M × $0.10 = $0.20
Input: 2M × $1.00 = $2.00
Output: 2M × $5.00 = $10.00
= $12.20/day
Winner: Mercury 2 (by a wide margin)
This is where diffusion’s structure matters.
Mercury:
- Cached pricing parity
- Much cheaper output
- Dramatically higher throughput
In agent workflows, latency compounds. A 5-step loop at ~1.7s E2E behaves very differently from one that stretches into double-digit seconds.
What About Quality?
Looking at the benchmark image:
Mercury 2:
- GPQA Diamond: 74
- LCB: 67
- IFBench: 71
- AIME: 91
GPT-5 mini (medium reasoning):
- GPQA: 80
- LCB: 69
- IFBench: 71
- AIME: 48
Claude Haiku (reasoning):
- GPQA: 67
- LCB: 62
- IFBench: 54
- AIME: 84
Mercury is not a “cheap but weak” model. It competes on reasoning benchmarks while dramatically outperforming in speed.
That matters when cost savings don’t come at the expense of capability.
The Real Decision Boundary
If cache pricing is equal, output pricing becomes the lever.
With both GPT-5 mini and Mercury 2 offering $0.025/M cached input, the economics shift dramatically.
Mercury 2 is almost always cheaper whenever output volume is meaningful.
GPT-5 mini only becomes the lower-cost option if:
- You value the models specific quality profile over cost efficiency
- You have edge cases where it outperforms materially on your task
Claude Haiku becomes rational only if:
- You specifically prefer Claude’s behavioral style or policy characteristics
- You can amortize cache writes across many stable hits
- Cost is secondary to ecosystem alignment or model preference
Once cache parity exists, the dominant question becomes:
How much are you generating?
Because $0.75/M output versus $2.00/M output compounds very quickly.
Final Take
Most companies don’t overspend because models are expensive.
They overspend because their model choice doesn’t match their token distribution.
In the agentic era, token spend is determined less by the headline price and more by where tokens accumulate:
- Cached context
- Fresh input
- Generated output
- Loop iterations
With identical cache pricing, Mercury 2 now has structural cost advantages in most balanced or generation-heavy workloads due to cheaper output and significantly higher throughput.
GPT-5 mini is no longer the automatic “cheap” choice in validator-style systems if output is non-trivial.
Claude Haiku remains the premium option, powerful in specific contexts, but rarely the economic winner at scale.
If you’re optimizing production token spend, you’re not just choosing a model.
You’re choosing the pricing curve that best matches your token geometry.
And once performance sits in the same tier, cost curve alignment becomes the real differentiator.
Check out our latest interview with cofounder Stefano Ermon below!
