If you run Claude Code or Codex every day, you know the feeling. It's Wednesday, and you've already hit your limit. Or the API bill came in, and it's twice what you planned.
The usual answer is "buy a bigger plan." We think the real reason is simpler, and it's one we lived through.
The fear tax
When you don't know which model can do which job, you play it safe. You pick the biggest model, for everything.
It feels responsible. Nobody gets blamed for using the best model. But most of what an agent does in a day isn't hard: reading files, running tests, tidying a branch, writing a status note, planning the next small step. The biggest model does that work fine. So does a model that costs a fraction as much.
We call this the fear tax: what you pay for using the top model on work that didn't need it. On a busy agent, it's a big share of the bill.
We paid it ourselves
Ekamyth is built by a team of AI agents, working with me. When we started, every agent ran on Fable, the top model we had. Every call. Our plans ran dry fast.
So we stepped down to Opus for everything. Even that wasn't enough. With hundreds of agents working at once, our subscriptions still ran out early in the week, and our API spend kept climbing.
It wasn't sustainable, and it wasn't smart. So we asked a plain question: what if each piece of work went to the model that's right for it? Planning, housekeeping and fixes could go to Sonnet. The hard work could stay on Opus.
That's how routing started. Like almost everything in Agent OS, we built it because we needed it to build our own company.
Right model, right work
Routing in Ekamyth Agent OS chooses the model for each call, based on the kind of work it is and what it has learned about which model does that work well.
Four things we were careful about.
It decides before the call, on your machine. Your agent's call passes through Agent OS on your own machine. The model is chosen there, before the call goes out. Hosted routers sit between you and your provider. Agent OS doesn't: the call goes straight from your machine to your provider.
It won't make you pay twice for your prompt cache. Long agent sessions lean on your provider's prompt cache: the part of the prompt that repeats is read from a warm cache at a fraction of the price. The cache belongs to one model. Switch models mid-session and the new model has to write that prefix to its cache again, at full price or more. Routing that ignores this can cost you more than it saves. So before Agent OS moves a call, it weighs what rebuilding the prompt cache on the new model would cost.
It only uses the models you already have. Routing moves work within your own provider, to a smaller model from the same provider, with your own key or sign-in. Your Claude plan stays your Claude plan. Your prompts and responses go straight from your machine to your provider.
It keeps learning from outcomes. Routing watches how the work turns out and learns which model does which kind of work well. If a moved call fails, Agent OS replays it on the model your agent asked for, so your agent still gets an answer. On our own fleet, a guard also compares routed work with the same kind of work kept on the top model, and sends a kind of work back if it starts to slip. Cheaper never wins over getting the work done.
And the hard stuff stays on the top model: reviews, security checks, first builds and other critical work don't move.
What it did to our numbers
Here's what happened when we routed our own fleet's jobs, week by week. (Our fleet picks a model for each job. The product goes further and picks for each call.) In week 1, before we turned routing on, nearly all our routine work ran on the top model. By week 3, about 9 in 10 routine jobs (fixes, tests, merges, ops, housekeeping and planning) ran on the smaller model, on both Claude and Codex.
The rest is on purpose. About 1 in 10 job families stays on the top model as a control, so we can measure what routing actually saves. And the hard work stayed on the strong model every single week: 98 to 100% of it on Claude, all of it on Codex.
Against that control, routing cut the model cost of routable work by about 80%¹: about 71% on Claude and about 85% on Codex.
To be straight about what that number is: it's gross model cost at public list prices, on our own fleet's mix of work, from one four-day window (2,158 routed jobs) against a small random holdout.
Work backwards from 80% and you get the number that matters to anyone on a plan. If routable work costs about a fifth as much, the same subscription or API budget does up to 5x the work.
On everyday work, that's the difference between hitting your limit on Wednesday and getting through the week.
Did the work still get done?
Saving money means nothing if the work stops getting done. So in the same window we compared how often the agents reported a job as finished, routed against kept on the top model.
Routed jobs reported finishing about 2 points less often: 96.6% against 98.6% across both. On Claude it was 98.4% against 99.2%. On Codex, 95.6% against 98.2%.
So it's close, but not identical, and we won't pretend it is. The gap shows up in a few kinds of work. Codex fix rounds finished 92% of the time against 100%, and Codex housekeeping 88% against 93%. That's exactly what the guard is for: it watches each kind of work, and if routed jobs fall behind, that kind of work goes back to the top model.
One honest caveat on this number. "Finished" here is the agent's own verdict: the job ended without the agent blocking or failing it. It tells you the agents kept finishing, not that every result was right, and checking an agent's word is exactly what Agent OS is for. So the full controlled benchmark we're running now scores every task with hidden checks, not the agent's own report. We'll publish it, including where routing doesn't help.
Your computer doesn't ask you which core to use
Here's the way I think about it.
Your laptop has different kinds of processors. Fast cores, efficient cores, a graphics chip. When you open a file or play a video, you don't decide which one runs it. The operating system does, all day, without asking. You'd never go back to picking by hand.
Agents need the same thing. Models are the processors. Some are big and brilliant. Some are small and great at everyday work. Choosing between them, call by call, is the operating system's job, not yours.
So here's the lesson we'd pass on:
Don't hardcode the model. Let the system choose, and check what it chose.
If you're running agents today
- Look at where your tokens go. Most teams find the bulk of their calls are everyday work.
- Stop defaulting to the top model for everything. Keep it for reviews, security and hard builds.
- Measure against a control. Keep a slice of work on the top model, so you know what you saved and that the work still gets done.
- Let it be automatic. A rule you have to remember on every call won't survive a busy week.
With Agent OS, this is on from setup. Run hero route to see every call, the model your agent asked for, and the model that answered.
Routing is one way. There are more.
This post is only about routing. It's the biggest lever we've measured so far, but it isn't the only way agents waste tokens. Retries after failures, repeated context, caching, work that fails halfway and starts again: each one costs you. We'll take them one at a time in the next posts.
If you want the whole picture now, this explainer follows one agent call from start to finish and shows where the tokens go.
Until then: your subscription probably isn't too small. Your model choice is too big.
Try it out and see for yourself
This video walks you through getting started, in under two minutes.
Start free. Agent OS runs underneath Claude Code and Codex.
— Anupam
¹ On routable work in our own runs, at public list prices, with quality kept within acceptable limits: the same kinds of agent work run on a cheaper model versus kept on the default model. Results may vary based on your environment and workload.