---
title: "The Model-Switch Toll: When \"Cheaper\" Costs More"
description: "Moving an agent to a cheaper model mid-session can cost several times more than staying put. The arithmetic of the model-switch toll, and why the real routing question is when, not which."
date: "2026-10-20"
tag: "Model routing"
url: "https://zuzai.ai/blog/the-model-switch-toll"
markdown_url: "https://zuzai.ai/blog/the-model-switch-toll.md"
---

# The Model-Switch Toll: When "Cheaper" Costs More

*Published by ZuzAI on October 20, 2026 · 5 min read · [Canonical HTML](https://zuzai.ai/blog/the-model-switch-toll)*

Seven turns into an ordinary coding session, a router makes what looks like the obvious call: the last few exchanges seemed simple, so it moves the session off Claude Opus and onto Sonnet, a model that costs half as much per token. That one turn comes out about **4.5 times more expensive** than doing nothing. This is the arithmetic your router isn't doing.

## Anatomy of a backfire

Every request in an agent session resends the whole conversation: the system prompt, the tool definitions and every earlier turn. Prompt caching is what makes that affordable. The provider keeps a copy of the conversation so far, and re-reading it costs a small fraction of the normal input price. The API reports both sides on every response: `cache_read_input_tokens` for what was re-read from the cache, and `cache_creation_input_tokens` for what had to be written fresh.

Here is the turn where the "optimization" fires, with 76,000 tokens of earlier context, 2,000 new tokens and a 1,000-token answer, at Anthropic's current prices:

|  | Stay on Opus 5.5 | Switch to Sonnet 5.5 |
| --- | --- | --- |
| Earlier context, 76K tokens | $0.015 (re-read from cache) | $0.190 (written from scratch) |
| New input, 2K tokens | $0.010 | $0.005 |
| Answer, 1K tokens | $0.020 | $0.010 |
| **This turn** | **$0.045** | **$0.205** |

*Prices per million tokens, October 2026: Opus 5.5 $4 input, $20 output; Sonnet 5.5 $2 input, $10 output; cached reads $0.20 on both; writing to the cache costs 1.25 times the input price.*

Nothing malfunctioned. The provider billed correctly, the router classified correctly, the cheaper model answered correctly. The system worked exactly as designed, and the design was wrong, because it treated model choice as a per-question decision when the money lives at the session level.

## Why the meter runs backwards

Provider prompt caches belong to one model. Opus's stored copy of your session is worthless to Sonnet: there's no transfer, no conversion and no partial credit. Whichever model receives the next request either finds its own warm copy and re-reads it cheaply, or writes the whole thing from scratch at full price.

In a mature agent session, that history *is* the request. The new question on top is a rounding error next to tens of thousands of tokens of system prompt, tool definitions and accumulated turns. So the economics of any mid-session switch reduce to one number:

> **The toll:** context size × (the new model's cache-*write* price − the current model's cache-*read* price). It's a difference, not a gross number: staying put isn't free, because you keep paying the current model's re-read every turn. But the toll grows with every turn you wait, because the context only ever gets bigger.

The toll isn't a constant. It's a price difference, and it moves every time a price list does. Claude Haiku 5.5 is so cheap that writing a session into its cache costs less than re-reading it on Sonnet, so for prompts under 100,000 tokens a Sonnet-to-Haiku switch pays for itself on the spot. Above 100,000 tokens Haiku's price rises fivefold, and the toll is back.

## The discount you'll never collect

Suppose you pay the toll anyway. When does it pay for itself?

Later than anyone assumes. Once the new model's cache is warm, both models spend most of each turn on discounted re-reads, and today Opus 5.5 and Sonnet 5.5 charge exactly the same for those: $0.20 per million tokens. The ongoing saving comes only from each turn's new input and its answer, about $0.015 a turn in the example above. At that rate the $0.16 toll takes **about 11 more turns** to earn back, and sessions that keep growing push break-even further out, not closer.

Now ask how many sessions run eleven more turns after the point where they "got simple". Not many. The router buys a discount the session won't live to collect, and pays cash up front for it.

## The classifier grades the paste, not the ask

A second failure hides underneath the toll, and it decides *which* sessions get misrouted. Complexity classifiers read the whole message, and people paste things: a license file, a stack trace, a page of logs. A dense paste scores as a hard problem and pins the session to the priciest tier, while the actual question, one turn later, is "what is this?"

The paste is data; the ask is the task. A router that can't tell them apart upgrades sessions for boilerplate and downgrades them mid-thought, and every mistake pays the full toll in whichever direction it errs.

## "Which model?" is the wrong question. Ask "when?"

Here's the reframe that fixes routing: every session already has moments when the cache is cold on *every* model, and a switch costs nothing extra. A router that acts only in those moments, and holds still everywhere else, keeps the upside of model choice without ever paying the toll.

### The start of a session

Turn zero has no cache to lose. Choosing the right starting model is worth more than every mid-session correction combined.

### The start of a sub-agent

When an orchestrating agent hands a scoped task to a helper, the helper starts with an empty history, a narrow brief and a short life. Giving it a cheaper model at that moment is model choice with a toll of zero: the parent's warm cache never notices.

### The moments the cache dies on its own

A pause longer than the cache's lifetime, five minutes by default, lets the whole cache expire. Compaction rewrites the conversation history whichever model you use. In both cases most or all of the rewrite is already being paid for, so moving to a cheaper model at that point costs little or nothing extra, and usually saves money.

Everything else follows from one rule: **a warm cache is an asset; never break one without cause.** The same rule indicts habits that have nothing to do with routing: swapping tool definitions mid-session, injecting a changed system prompt, or rewriting the history to "compress" it. Each one breaks the cached prefix, and each one bills like a model switch.

## A smaller session shrinks every toll

The toll scales with context. A 15,000-token session pays a fifth of what a 75,000-token one does for the identical mistake, and much of the difference between those two numbers is noise: test runners echoing hundreds of passing tests, build tools reprinting dependency trees, logs that repeat themselves. The noise enters once, then gets billed again on every turn and multiplies every future cache write.

- **5x**: difference in switch-toll exposure between a lean 15K-token session and a bloated 75K-token one, before the router makes a single decision

## The bill is a design review

The turn-seven downgrade wasn't bad luck. It was a per-question answer to a session-level question. Price the toll, distrust the paste, switch in the free moments, keep the history lean, and model choice goes back to being what it was promised to be: a discount, not a surcharge with good intentions.

> **Where ZuzAI fits**
> ZuzAI records every AI request's model, tokens and cost, by person, tool and repository, so a switch that cost more than it saved shows up as a line item instead of disappearing into the monthly total. It runs inside your own tenant.