A cheap attempt can produce an expensive task
A low input and output token price makes a model look like the natural choice for a high-volume agent. One task may still require three retries, extra tool calls, and an escalation to a stronger model. The first attempt remains cheap while the verified result becomes expensive.
Price-table comparisons therefore miss the production question. The useful measure is cost per successful task: all model calls, cache misses, tools, retries, and infrastructure time divided by outcomes that pass a final verifier.
A model can be four times cheaper per token yet complete half as many tasks and leave external state uncertain. It may cost more per accepted result. The inverse is common too: a frontier model is used for mechanical formatting that a small model completes with the same verified outcome.
Cursor Router learns from production requests
Cursor Router classifies each request by context, complexity, and domain before selecting a model. The classifier was trained on more than 600,000 live requests and evaluated through online experiments across millions of requests. Users can choose three operating points between quality and spend.
Cursor reports 30% to 50% savings for early enterprise customers and up to 60% in online comparisons. For one committed code change, it reports $6.76 in its intelligence-oriented mode and $4.63 in balanced mode, compared with $12.69 and $7.34 for two individual model choices.
Those figures do not transfer directly to another product. Cursor optimized user satisfaction and the share of generated code that remains in a repository. Both are valuable production signals, but neither is a deterministic proof that the task was completed. A user may accept a plausible patch whose failure appears later.
The cache treatment is a more general contribution. Router evaluation includes cache misses caused by model switching. Routing happens within conversations, and a switch may force a large context to be processed again. A cheaper model can lose its price advantage when every handoff destroys cache reuse.
Small models have become credible workers
Recent releases make routing more practical. Google introduced Gemini 3.6 Flash and 3.5 Flash-Lite as fast tool-using models.
Gemini 3.6 Flash is priced at $1.50 per million input tokens and $7.50 per million output tokens. Google reports 17% fewer output tokens than the previous version, DeepSWE improving from 37% to 49%, and MLE-Bench from 49.7% to 63.9%.
Flash-Lite costs $0.30 and $2.50 per million input and output tokens, generates around 350 tokens per second, and supports adjustable thinking. Google reports Terminal-Bench 2.1 rising from 31% to 54%.
Every comparison is vendor-reported. The releases identify plausible low-cost workers, not the winner of a production evaluation elsewhere.
OpenAI also cut GPT-5.6 Luna's price by 80%. Luna costs $0.20 per million input tokens and $1.20 per million output tokens. Terra costs $2 and $12. Sol Fast offers up to 2.5 times the speed at twice the price with no claimed intelligence change.
This is an economic shift. An inexpensive worker can now call tools and complete multi-step workflows. The quality and cost-per-task claims still come from the vendor and its customers. Routing policy needs local evidence.
Evaluation must end in a verifier
Build a small stable set for each task family: bug fixes, interface changes, document analysis, terminal work, research, and external-service operations. Every case needs a verifiable final state.
Each run records success, time to first token, wall time, input and output tokens, cache hits, tool calls, retries, and escalations. Error cost is a separate field. A rejected draft and an incorrect payment should not contribute equally to one average.
The first useful router can be a table. Routine tasks go to the cheapest model that clears a required success threshold. Ambiguous, long, or high-impact tasks start with a stronger model. Escalation is triggered by observed events: repeated tool failure, an unresolved conflict, an exhausted budget, or a failed postcondition.
The router has its own failure modes and cost. Measure under-routing, where a cheap model receives a task it cannot complete, and over-routing, where an expensive model was unnecessary. Track late escalation separately because it spends most of the cheap-model budget before paying for the strong model anyway.
Token price remains an input
Pricing still belongs in the calculation; it should not be the objective. The target is cost per verified code change, processed document, or completed order. Latency-sensitive voice workflows add the cost of time: a slow correct answer may arrive after the caller has interrupted the agent.
A useful router does not search for one best model. It records which model brings each class of work to a verified state at the lowest total cost, then updates that decision as new measurements arrive.