Every time your code continues a conversation with Claude, it sends the whole history back: the system prompt, the tools, every earlier message and the reasoning Claude produced along the way. To stop distillation, the copying of Claude's reasoning to train other models, Anthropic's API now checks that history. Each earlier thinking block must come back with exactly the context that produced it. Change anything before it, and the request fails or Claude answers without that reasoning.
What changed
Claude's reasoning comes back to you as encrypted thinking blocks. Your code can store them and send them back, but it can't read them. Until now, though, nothing stopped it from editing the conversation around them.
On the four models above, the API binds each thinking block to everything that came before it: the system prompt, the tool definitions and the earlier messages. Adding new turns at the end is fine. Rewrite anything above a thinking block and the request fails, unless you opt into non-strict mode, which drops that block, tells you which one, and lets Claude answer without it.
Each thinking block is locked to the history above it
Add your next message at the end
Nothing above the thinking changed, so Claude keeps its reasoning.
Edit anything inside the dashed box
By default the API returns an error. In non-strict mode it drops that thinking block and says so.
Why: to stop distillation
Distillation means training an AI model to imitate a stronger one, the way a student might learn by copying a top student's worked answers:
- AskSend the strong model thousands of questions.
- CollectSave every answer and the reasoning behind it.
- CopyTrain a new model to answer the same way.
Done to someone else's model without permission, that's copying, and Anthropic's terms prohibit it. The copy can also end up with Claude's abilities but without the safeguards Anthropic builds against misuse such as cyberattacks and weapons development.
The reasoning is the part copiers want most, which is why Claude's thinking comes back encrypted. Editing the conversation before a thinking block was a known way to make Claude reveal it anyway. Checking the history closes that gap.
Who it affects today
The check starts with new accounts, where Anthropic sees the most copying, so existing customers get time to adapt.
| Accounts created on or after Aug 31, 2026 (00:00 UTC) | Older accounts | |
|---|---|---|
| The Claude APIClaude Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5 | Checked now | Not yet: follows with upcoming model launches |
| Claude Code, Claude Cowork, Claude.ai | Nothing to change | Nothing to change |
An account here is a Claude Platform organization, an Amazon Bedrock account, a Google Cloud Vertex AI project or a Microsoft Foundry project. Source: Anthropic.
That has a practical catch: a new AWS account or Google Cloud project, say for a new environment, gets the check first. The same code can work in an older production account and fail in a newer staging one, so test against your newest account.
Where the edits hide
Few teams think they rewrite history, but these everyday patterns do:
| What your integration does today | Do this instead |
|---|---|
| Compacts the conversation itselfdrops or summarizes older turns to save tokens | Let the API do it with compaction (beta): it summarizes older turns, keeps the latest ones word for word and can build the summary in the background. |
| Rebuilds the system prompt every turnwith the date, the environment or a reminder | Send it once and resend it unchanged. Put anything new in the newest turn, as text or a mid-conversation system message. |
| Adds or removes tools mid-session | Use mid-conversation tool changes (beta), which change the tool list without editing earlier turns. |
| Trims old tool results later | Shorten a result before you first send it, never after. |
| Runs requests through middlewareserializers, SDK wrappers, proxies | Check that it sends thinking blocks back exactly as received. A serializer that drops empty fields or reorders blocks counts as an edit. |
Check each feature's page for availability on Amazon Bedrock, Google Cloud Vertex AI and Microsoft Foundry. Anthropic's preserved thinking documentation and migration guides cover the remaining cases.
Thinking now belongs to one account
A second rule starts with Claude Sonnet 5.5: a thinking block can be read only by the account that created it, or by an account linked to it. That keeps a leaked or shared transcript from exposing private reasoning, and stops distillers from moving harvested transcripts to fresh accounts after a ban.
Who can read a thinking block
Sent back by account A, or an account linked to it
Claude reads its earlier thinking. Accounts in the same Claude Platform parent organization, or the same Google Cloud organization, are linked automatically.
Sent back by any other account
The thinking is dropped without an error, and the next response is slower and uses more tokens.
This rule never returns an error, so its cost hides in the next response: slower, with more tokens, much like after a compaction. Two places to look:
- Failover between providers. If conversations move between the Claude Platform and Amazon Bedrock, ask your account team to link the accounts, or each failover costs a slower, pricier turn.
- Switching accounts in Claude Code. A developer who changes accounts mid-session, say from a personal login to the company's, pays the same price on the next turn.
Append-only pays twice
Leaving history alone pays a second time. Prompt caching works only while each request starts exactly like the one before it, so an edit that trips the thinking check also throws away the cache from that point on, and everything after it is billed at full price again. Anthropic says as much: consistent thinking blocks mean more cache reuse, lower cost and faster responses.
Model routing pays twice too. A mid-session switch already costs the cache (see The Model-Switch Toll), and because Anthropic limits moving reasoning from more capable models to less capable ones, switching down a tier can cost the reasoning as well.
So one rule now covers reasoning, cost and speed: add to the end of a conversation, and never rewrite the middle. If your code, or anything between it and the API, rewrites earlier turns, find it now, before the check reaches older accounts with the next model launches.
Where ZuzAI fits
ZuzAI records every AI request's model, tokens, cache reads and cost, by person, tool and repository, so a turn that suddenly costs more than the one before it shows up as a line item instead of disappearing into the monthly total. It runs inside your own tenant.
Published by ZuzAI on November 5, 2026.
