Model routing means sending each request to the cheapest model that still solves the task at the quality you need, instead of sending everything to a single expensive model. In production I implemented it with OpenRouter as a single access layer: DeepSeek for the bulk of traffic (classification, extraction, summaries) and a premium model like Claude only for the cases where quality is critical. It's the most direct way to cut AI costs without users noticing a difference, because most real requests don't need the most expensive model.
TL;DR
- Send the bulk of traffic (classify, extract, summarize) to a cheap model like DeepSeek and reserve premium (Claude) only for the hard cases.
- Validate the cheap model's output and escalate to premium only when it fails. Clean the JSON (fences, trailing commas) before giving up, so you don't escalate unnecessarily.
- Measure everything by model and feature. With volume and tasks of uneven difficulty, savings land around 80-90%.
What model routing is and why it cuts costs
The underlying idea is simple: not all LLM requests have the same difficulty. Classifying a text into one of three categories doesn't require the same model as drafting a nuanced legal reply. When you send everything to the top model, you pay a premium price for tasks a cheaper model solves just as well. That's where the money goes: not on volume, but on using expensive capacity for cheap work.
Routing breaks that uniformity. You define rules or a complexity signal, and based on that you pick the destination model. The price gap between model tiers is several orders of magnitude per million tokens, so moving even a fraction of the traffic to the cheap tier changes the bill entirely. That's why routing is, in practice, one of the most effective ways to save tokens and lower the cost of an AI project.
How much you can save
Let me start with what almost everyone wants to know before reading the rest: how much you save.
An example with public OpenRouter prices (June 2026): DeepSeek V4 Flash costs about $0.09 per million input tokens and $0.18 output, while a premium model like Claude Opus runs around $5 input and $25 output. For a workload of 50 million input tokens and 10 million output per month:
- Everything on premium: on the order of $500 a month.
- 90% on cheap, 10% on premium: around $55 a month.
Monthly cost (example: 50M tokens in / 10M out)
All premium ████████████████████████████ ~$500
With routing ███ ~$55
↓ ~89% less
That's close to a 9x reduction just by separating the easy tasks from the hard ones. The exact numbers depend on your traffic mix, but the order of magnitude holds: when the expensive model goes from solving 100% to solving 10%, the bill drops almost proportionally.
In one of my projects with this traffic pattern, the monthly bill dropped from roughly $430 to $60 after introducing routing, with about 90% of requests handled by the cheap model. These are rounded figures and depend on the project, but the order of magnitude holds as long as you have volume and a mix of tasks of uneven difficulty.
DeepSeek vs Claude: which tasks the cheap model can handle
The "without losing quality" promise only holds if you know which tasks the cheap model can take on and which it can't. This is the part that really decides whether routing works: picking the right LLM model for each type of task, not the most capable one for everything.
My rule, based on tests over real traffic, ended up like this:
| Task type | DeepSeek quality vs Claude | Needs premium? |
|---|---|---|
| Classification | Equivalent | No |
| Field extraction | Equivalent | No |
| Summaries | ~98% of premium | Rarely |
| User-facing writing | ~90% | Yes |
| Multi-step reasoning | ~70% | Yes |
These are approximate figures from my tests over real traffic, not a formal benchmark, but the pattern is clear: where the output follows a predictable, verifiable format (classify, extract, summarize), the cheap model performs very close to premium. Where you need open-ended reasoning, strict adherence to long instructions, or nuanced writing, premium does make a difference. That's why DeepSeek isn't "the model", it's the default model, with an escape route to something more capable.
Keep reading
That is the first half. The full walkthrough — with the rest of the implementation, the trade-offs and the things that only show up in production — is on my blog:
Read the full post on ramonchancay.me →
Originally published at www.ramonchancay.me/blog/model-routing-openrouter-deepseek.
Top comments (0)