Route by difficulty: one Cursor month, two models
Almost every Cursor session is a mixture. A handful of turns are genuinely hard. A refactor that touches six files, a bug whose cause is not yet known. The majority are mechanical: rename a symbol, add an import, write a test stub, move a block. Both kinds go to the same model, at the same rate.
Cursor lets you change models between turns from the picker, and the conversation carries over. So the split is available without leaving the editor and without any routing layer in between It is a habit, not an integration.
To price it, take a normal day of Cursor work: A day of work on this page's workload is 150k input and 40k output tokens — 3M input and 0.8M output across a 20-day month. What follows is what that month costs on five models when it is sent to one of them, and what it looks like once the mechanical share is moved.
https://aicomp.ai/v1).
Create one free →
What the mechanical share is worth
| Model | Gateway rate in / out per 1M tokens | One day | 20 days |
|---|---|---|---|
| claude-opus-5 | $2.5 / $12.5 | $0.88 | $17.50 |
| claude-sonnet-5 | $1.00 / $5.00 | $0.35 | $7.00 |
| gpt-5.6-luna | $0.10 / $0.60 | $0.04 | $0.78 |
| deepseek-v4-flash | $0.15 / $0.60 | $0.05 | $0.93 |
| MiniMax-M3 | $0.15 / $0.60 | $0.05 | $0.93 |
One day = 150k input + 40k output on this page's workload. 20 days = 3M input and 0.8M output. Rates checked 2026-10-28, gateway rates move with upstream promotions, so verify the current number in your dashboard before committing to a budget.
Read the monthly column, not the input column. On a Cursor workload input dominates (every turn re-sends the accumulated context) so the per-token input rate moves the bill far more than the output rate does, which is the opposite of a terminal agent's shape.
Now consider what happens when most of that input traffic goes to the cheapest row instead of the strongest one. If three turns in four are mechanical and you send them to the cheap model, the expensive model is only paid for the turns that needed it. The published savings figures for this split cluster around 60 to 80 percent, and they are not mysterious: it is arithmetic on the input column, applied to the majority of turns.
Sorting turns into three buckets
Mechanical. Rename, import, formatting, a test skeleton, a docstring. A small model does these indistinguishably from a large one, and they are the bulk of a session.
Local. One file, understood boundaries. Add a parameter, fix a condition, rewrite a function against an existing pattern. Mid-tier handles these; a frontier model is usually paying for capacity that goes unused.
Open. You do not yet know what is wrong, or the change spans modules. This is where a strong model earns its rate, because a wrong first attempt costs a full retry at full context price.
The discipline is to decide which bucket a turn is before sending it, not after. The expensive failure is not using a strong model on an easy turn It is using a cheap one on an open-ended turn and paying for the same context twice.
What it costs you
Two real costs, and both are worth stating plainly.
You have to notice the bucket. The split only works if you switch models deliberately. Left on one model, nothing changes. On a busy day this is one extra decision per turn.
Context is not free to move. Switching models mid-session keeps the conversation, but the incoming model has not seen what the previous one cached. Expect the first turn after a switch to re-establish context rather than continue it.
Neither is large. Both are the reason the savings are real rather than theoretical, if routing were free and automatic, everyone would already be doing it.
Where this sits next to the other levers
Fewer turns per task comes first, and it is free: cutting turns removes tokens from every later request in both directions. Routing comes second, and it is the largest lever that does not require changing how you work. Model choice by list price comes last It is a table lookup once the shape is fixed, and on this workload it matters less than either.
FAQ
FAQ
How much does routing by difficulty actually save?
Published figures for this split cluster around 60 to 80 percent of spend, because the mechanical turns are the majority of a session and input tokens dominate a Cursor workload. The table above gives the monthly figure per model so you can check it against your own split.
Does switching models mid-conversation lose the context?
The conversation carries over, but the new model has to read it rather than resume it. Expect the first turn after a switch to spend tokens re-establishing context, which is why switching many times inside one task defeats the purpose.
Which tasks should stay on the strongest model?
The ones where you do not yet know the answer, diagnosis across files, a refactor whose full extent is unclear. A wrong first attempt there costs a retry at full accumulated context, which is more than the rate difference you were trying to save.
Is this different from just picking a cheaper model for everything?
Yes. Picking one cheap model applies the cheap rate to the turns that needed a strong one, and those are the turns where a retry costs the most. Routing keeps the strong rate on the minority of turns that justify it.
Why does input price matter more than output price on Cursor?
Because every turn re-sends the accumulated conversation, so input grows through a session while output stays proportional to the answer. That is the opposite of a terminal agent that returns whole files, where output dominates.
Related
- Cursor API cost — the same workload without the split
- Coding agent cost per month — how other agent shapes compare
- Cheapest models by workload (pick by shape), not list price
- Model fallback chain — routing when a model is unavailable
- Cursor with an OpenAI-compatible endpoint — where the model list comes from
- How to calculate LLM cost — the method behind these numbers