
Switching Claude Models Mid-Conversation: What Gets Dropped
You can switch Claude models mid-conversation by changing modeland sending the whole history. The switch never causes an error. If the new model can't read the earlier thinking blocks, the API quietly drops them and doesn't bill them, and the new model redoes the reasoning. That redo is the part nobody prices in. In my tests it made the next turn about 2.4x slower and up to 47% more expensive. I ran 288 API calls across Haiku 5.5, Sonnet 5.5, Opus 5.5, Fable 5.1 and Fable 5.2 this morning to map exactly which switches keep the reasoning and what the drop costs.
Which Model Switches Keep the Thinking?
Each of the five models answered a first turn with adaptive thinking on. Then I sent that exact history, thinking block and all, to every one of the five models with the thinking-binding-controls-2026-08-01 beta header, which adds an input_transformationsarray to the response. Two seeds and two prompt variants gave me 100 switch requests. Here's what got read (✓) and what got dropped (✗):
| Block written by ↓ / sent to → | Haiku 5.5 | Sonnet 5.5 | Opus 5.5 | Fable 5.1 | Fable 5.2 |
|---|---|---|---|---|---|
| Haiku 5.5 | ✓ read | ✓ read | ✓ read | ✗ dropped | ✓ read |
| Sonnet 5.5 | ✗ dropped | ✓ read | ✓ read | ✗ dropped | ✓ read |
| Opus 5.5 | ✗ dropped | ✗ dropped | ✓ read | ✓ read | ✓ read |
| Fable 5.1 | ✗ dropped | ✗ dropped | ✗ dropped | ✓ read | ✓ read |
| Fable 5.2 | ✗ dropped | ✗ dropped | ✗ dropped | ✗ dropped | ✓ read |
All 100 requests returned 200, and every drop matched Anthropic's published table. The preserved thinking docs were right, which I don't take for granted. Every dropped block came back as thinking_dropped with reason model_binding_mismatch.
The pattern is easier to remember than the grid:
- Moving up the ladder keeps the reasoning. Haiku to Sonnet, Sonnet to Opus, anything to Fable 5.2.
- Moving down drops it. Opus to Sonnet, Sonnet to Haiku, Opus to Haiku.
- Fable 5.2 is a one-way door. It reads everyone, and nobody reads it, not even Fable 5.1. I covered that change in my Fable 5.2 vs 5.1 comparison.
- Fable 5.1 is the odd one. It reads Opus 5.5 but not Sonnet 5.5 or Haiku 5.5, so it makes a poor escalation target for a cheap-first router.
Are Dropped Thinking Blocks Billed?
No. For every switch I also sent the same history with the thinking block stripped by hand. A dropped request billed exactly the same input tokens as the stripped one: 199 and 199 on the short prompts, 373 and 373 on the puzzle. A kept block, on the other hand, is billed as normal input. Opus 5.5's first-turn block added 2,060 to 2,320 input tokens to the next request.
So a drop looks free on the invoice line for input. It isn't free, because the model now has to think its way back to where the last model already was.
What Does Dropping the Reasoning Actually Cost?
I needed a first turn where the thinking does real work and the visible answer gives none of it away. So turn one was a seven-person on-call scheduling puzzle with 10 rules, and the instruction was to reply with only the number of valid schedules. The answer is 11, which I checked by brute force over all 5,040 orderings. Turn two added a rule (Ana isn't on Monday) and asked for every schedule that still works. There are exactly 3.
The first model gets the count right and shows nothing else. A second model that can read the thinking can filter the 11 schedules it already found. A second model that can't has to solve the puzzle again. I ran each path three times at effort: high and compared the block kept against the same history with the block removed, which is exactly what a drop does:
| Turn 1 → turn 2 | Kept: thinking | Kept: time | Kept: cost | Dropped: thinking | Dropped: time | Dropped: cost |
|---|---|---|---|---|---|---|
| Opus 5.5 → Opus 5.5 | 603 | 7.3 s | $0.024 | 2,135 | 18.6 s | $0.046 |
| Opus 5.5 → Fable 5.2 | 518 | 6.3 s | $0.045 | 1,562 | 15.3 s | $0.069 |
| Sonnet 5.5 → Opus 5.5 | 776 | 7.9 s | $0.030 | 1,949 | 17.7 s | $0.042 |
| Opus 5.5 → Sonnet 5.5 | can't read | 1,966 | 14.2 s | $0.021 | ||
| Sonnet 5.5 → Haiku 5.5 | can't read | 6,306 | 23.2 s | $0.003 |
Averages of 3 runs. Thinking is output tokens spent on thinking in turn two. Cost is turn two only, at list price.
When the next model could read the block, it thought 60-72% less, answered 55-61% faster and cost 30-47% less. That holds even though the kept requests carried 6.5-8.6x more input tokens (2,430 to 3,210 against 373). Thinking is output, output costs five times what input does, and re-deriving 11 schedules is a lot of output.
Accuracy didn't move. All 36 second-turn answers listed exactly the right 3 schedules, and all 6 first turns said 11. On a puzzle this size, the dropped models just paid in time and tokens to get back to the same place. On a long agent task where the earlier reasoning held a plan or a dead end it already ruled out, I'd expect a drop to hurt quality too. I didn't measure that, so treat it as a guess.
The last row is the one to look at if you route cheap. Haiku 5.5 can't read Sonnet's block, so it re-solved the puzzle from scratch with 6,306 thinking tokens. That's less than half a cent, and it was the slowest path in the test at 23 seconds. Cheap in dollars, expensive in wall-clock.
What Happens When You Switch Away and Back?
I took an Opus 5.5 history, sent one turn to Haiku 5.5 ("Reply with only: ok"), then went back to Opus with the puzzle follow-up. On the Haiku leg the Opus block was dropped, as expected. Haiku also spent 4,475 thinking tokens on a reply that was the word "ok", apparently re-working a puzzle it was never asked to answer.
Back on Opus, input_transformationswas empty. Opus read its own block again, plus all 4,475 tokens of Haiku's thinking, because Opus can read Haiku. The request billed 6,858 input tokens and got the right answer in 6.4 seconds.
Two lessons. First, a drop is per request, not permanent. The API never edits your messages, so reasoning only gets lost for good if your own code strips it. Keep one history for all models. Second, a cheap model's thinking doesn't stay cheap. When you come back up, the bigger model reads it as input at its own rate.
How Do You See What Got Dropped?
Without the beta header there's no signal at all. I sent the same Opus-to-Sonnet switch without it, and the response had no input_transformations key. The request succeeded and the thinking was gone, with nothing to tell you. With the header, log every entry:
import anthropic
client = anthropic.Anthropic()
def ask(model: str, history: list) -> anthropic.types.beta.BetaMessage:
resp = client.beta.messages.create(
model=model,
max_tokens=16000,
system=SYSTEM, # identical on every model
tools=TOOLS, # identical on every model
thinking={"type": "adaptive"},
messages=history, # full history, thinking blocks untouched
betas=["thinking-binding-controls-2026-08-01"],
)
for t in resp.input_transformations or []:
# model_binding_mismatch: expected after a switch
# prefix_binding_mismatch: your code edited the history, fix it
log.info("dropped %s at %s (%s)", t.type, t.path, t.reason)
history.append({"role": "assistant", "content": resp.content})
return respTwo reasons matter for a router:
model_binding_mismatch: the switch dropped it. Not a bug. If you see it a lot on follow-up turns, your routing is moving down the ladder right after the expensive turns.prefix_binding_mismatch: your code changed something before the block. That one is yours to fix.
The block_binding setting comes with a catch. Sonnet 5.5 with thinking: {type: "between_tools"} rejected it with Extra inputs are not permitted, so a route that runs Sonnet with thinking off needs its own request shape.
Why Does My Router Get a 400 After a Switch?
Not because of the switch. The 400s I could produce came from editing the history, which routers often do on the side: a per-model system prompt, a tool list trimmed for the cheap model, a "be concise" line appended for Haiku. I changed one word in the first user message, and separately appended two words to the system prompt, then sent an Opus 5.5 block back:
- Fable 5.2: 400 on both edits.
- Opus 5.5 and Fable 5.1: 200, with a
thinking_mismatch_allowedentry. The block was read and billed anyway (2,372 input tokens). My account predates August 31, 2026, which is why it isn't enforced there yet. Newer accounts get the 400 on these models too. - With
prefix_mismatch_behavior: "drop_block": 200 on all three, block dropped, 373 input tokens.
400 invalid_request_error
messages.1.content.0: Invalid `signature` in `thinking` block. The block is bound
to a different conversation. Remove the block, or set
`thinking.block_binding.prefix_mismatch_behavior` to "drop_block". ...
The `system` prompt differs from the one this block was created with.The error names what changed, which saves a lot of guessing. One small thing I noticed: appending a single trailing space to the user message did not trip the check. Changing a word did. The fix is to keep system and tools byte-identical across every model in the route and send per-model instructions as a mid-conversation system message at the end instead. That also keeps your prompt cache intact within each model (caches are per model, so a switch always starts a cold cache).
One more request-shape trap. If any of your models used to run thinking: {type: "enabled", budget_tokens: N}, Fable 5.2, Sonnet 5.5 and Haiku 5.5 all reject it: "thinking.type.enabled" is not supported for this model. Send adaptive everywhere and set depth with effort.
Don't Test This by Asking Claude What It Thought
My first attempt at proving the reasoning carried over was a memory game. Turn one: pick a secret 4-digit number in your reasoning and reply only "ready". Turn two: which number did you pick? Every one of the 100 second-turn requests came back with stop_reason: refusal and category reasoning_extraction, on all five models, including the ones reading their own block. Rewording it as "add 1111 to your number" still got refused 55 times out of 100. The other 45 answered "none" or explained they had no access to the number, so not one of them actually used it.
So prompts that ask about earlier reasoning trip a safety classifier. If you build an eval for your router, measure carry-over the way I did here: a task where the earlier reasoning makes the next turn cheaper, plus input_transformations and billed tokens.
How Should a Claude Model Router Switch Models?
- Escalate, then stay up for the follow-ups. If Opus did the hard turn, the next two turns about that work should stay on Opus (or go to Fable 5.2). Dropping to Sonnet right away throws the reasoning out and makes Sonnet think it all again.
- De-escalate at a topic boundary.When the user moves on to something new, the old reasoning isn't worth much, and the drop costs little.
- Treat Fable 5.2 as the last stop. Once a conversation has Fable 5.2 thinking in it, any other model works without it.
- Never strip thinking blocks yourself,and never keep a separate history per model. The API already drops what can't be read, at no charge.
- Price the whole task, not the request. In my runs the cheaper model on turn two was sometimes the slower and pricier choice once it had to redo the work. Before you build a cascade at all, check whether one model at lower effort does the job. I compared those options in my Haiku 5.5 cost test and the advisor tool vs subagents post.
How I Tested
November 21, 2026, from a Mac mini in Allen, TX, against the Claude API with plain HTTP from Python. Models: claude-haiku-5-5, claude-sonnet-5-5, claude-opus-5-5, claude-fable-5-1 and claude-fable-5-2, adaptive thinking, display: "summarized" on the first turn of the matrix test. The switch matrix used 5 source models x 2 seeds x 5 targets x 2 prompts, each with a block-kept and a block-stripped request. The puzzle test ran 3 first turns each on Opus 5.5 and Sonnet 5.5 and 36 second turns. I also ran a 5-pair tool-use loop (a support agent with two tools), but adaptive thinking skipped (or nearly skipped) reasoning before the first tool call at effort: high, so there was nothing to drop and every switch went through cleanly. Everything together came to 288 calls and $2.23 at list price. One task type and one account, so check your own traffic before you change a production router.
Routing Claude Across Models?
I build Claude agents and routers that run in production, and I measure what each model hop really costs before shipping it. If your bill or your latency went up after adding a cheaper model, send me your routing logic.
Related Posts
AI Agents
Claude Message Threads: Tested TTFT, 404s and Cost
I benchmarked Claude message threads on Haiku and Sonnet 5.5: requests shrank from 376 kB to 21 kB, median time to first token dropped 17% past 100K tokens, the token bill didn't move, threads died between 4:50 and 5:20, and dropping cache_control on a continue silently turned caching off.
AI Agents
Claude API OpenTelemetry Tracing: Setup and 6 Gotchas
Claude API OpenTelemetry tracing went into public beta on October 14, 2026: SDK spans from one tracer provider, API spans from a Console destination. Tested on Python SDK 1.14.0, gen_ai.usage.input_tokens already includes cache tokens (12 uncached reported as 10,252), unsampled traceparents drop the API spans too, and abandoned streams never end their span.
AI Agents
Claude Web Fetch url_not_in_prior_context Error, Fixed
Claude's web_fetch refuses URLs nobody handed it: anything only in the system prompt, Claude's own output or an MCP/code-execution result. Which sources count on the Messages API vs Managed Agents (stricter since Oct 7), how to catch the error inside a 200 response, and the fix for each case.