---
title: "Preserved Thinking: Rewrite the Past, Lose the Reasoning"
description: "Claude's API now checks that each thinking block comes back with the exact history that produced it. What changed, who it affects and what to do instead."
date: "2026-11-05"
tag: "Claude API"
url: "https://zuzai.ai/blog/preserved-thinking"
markdown_url: "https://zuzai.ai/blog/preserved-thinking.md"
---

# Preserved Thinking: Rewrite the Past, Lose the Reasoning

*Published by ZuzAI on November 5, 2026 · 5 min read · [Canonical HTML](https://zuzai.ai/blog/preserved-thinking)*

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.

- **4 models**: check it today: Claude Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5
- **Aug 31, 2026**: accounts created on or after this date are checked now; older accounts follow with upcoming model launches
- **0 changes**: for Claude Code, Claude Cowork and Claude.ai, which handle thinking blocks themselves

## 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.

**Chart — Each thinking block is locked to the history above it**
*Everything above a thinking block must come back unchanged. New messages go below it.*

## 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:

1. **Ask** — Send the strong model thousands of questions.
2. **Collect** — Save every answer and the reasoning behind it.
3. **Copy** — Train 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 API** (Claude 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](https://support.claude.com/en/articles/16761192-preserved-thinking-changing-how-the-messages-api-handles-thinking-blocks-to-protect-against-distillation).*

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 itself** (drops or summarizes older turns to save tokens) | Let the API do it with [compaction (beta)](https://platform.claude.com/docs/en/build-with-claude/compaction): it summarizes older turns, keeps the latest ones word for word and can build the summary in the background. |
| **Rebuilds the system prompt every turn** (with 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](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages). |
| **Adds or removes tools mid-session** | Use [mid-conversation tool changes (beta)](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages#mid-conversation-tool-changes), 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 middleware** (serializers, 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](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking) and [migration guides](https://platform.claude.com/docs/en/about-claude/models/migration-guide) 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.

**Chart — Who can read a thinking block**
*Your Anthropic account team can link accounts across organizations and clouds, for example a Claude Platform organization and an Amazon Bedrock account.*

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](https://zuzai.ai/blog/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.