What this read moved
1–7 of 7build-with-claude/preserved-thinking Changed · +46 / -0 lines
## FAQ
from line 296
296296* Cross-turn files are `file_id` or base64, not mutable URLs.
297297* A production `prefix_mismatch_behavior` is set and its 400s or dropped entries are monitored.
298298
299## FAQ
300
301<AccordionGroup>
302 <Accordion title="Do I need a new account to test the check?">
303 No. Send the `thinking-binding-controls-2026-08-01` beta header and set `thinking.block_binding.prefix_mismatch_behavior`. Setting the field opts that request into enforcement regardless of account age: `"error"` rejects an edited history with the same 400 a new account gets, and `"drop_block"` lets the request through and lists what was dropped in `input_transformations`. See [How to tell whether your integration is impacted](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted).
304 </Accordion>
305
306 <Accordion title="If anything before a thinking block changes, even one tool description, is the conversation unusable?">
307 No. What fails is the thinking already in the history after the point you changed, and you choose what happens to it. With `prefix_mismatch_behavior: "drop_block"` the API drops those blocks and the request succeeds: the model answers that turn without that reasoning, and the prompt cache restarts at the edit. With the default `"error"` the API rejects the request with a 400 until you undo the edit or resend with `"drop_block"`; see [Decide what happens on a mismatch](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#decide-what-happens-on-a-mismatch). [What counts as an edit](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#what-counts-as-an-edit) lists which changes matter.
308 </Accordion>
309
310 <Accordion title="Does changing effort or other thinking settings between requests invalidate earlier thinking?">
311 No. `output_config.effort`, `max_tokens`, and the `thinking` configuration aren't part of the checked prefix, which covers only `system`, `tools`, and `messages`. A top-level effort change still invalidates most of the prompt cache; on Claude Fable 5.1, a [per-message effort](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta) change keeps it. Once sent, that effort message is part of the history: leave it in place on later requests.
312 </Accordion>
313
314 <Accordion title="My tool list changes mid-session. How do I avoid invalidating the conversation?">
315 Don't edit `tools`: declare the full set at session start, mark tools that aren't available yet `defer_loading: true`, and offer or withdraw them with `tool_addition` and `tool_removal` blocks. A tool whose schema you learn only mid-session, such as one from an MCP server discovered at runtime, can still be appended to `tools` with `defer_loading: true` and offered the same way, because an unreferenced deferred tool isn't part of the prefix. The `role: "system"` messages that carry these blocks join the prefix for later thinking, so don't move, reword, or delete them afterward. See [Change tools with `tool_addition` and `tool_removal`](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#change-tools-with-tool-addition-and-tool-removal-not-by-editing-tools).
316 </Accordion>
317
318 <Accordion title="I compact by summarizing older turns and keeping recent turns verbatim. Does that still work?">
319 Not if the kept turns still carry their thinking: those blocks were produced against the history you replaced, so they fail the check. Strip `thinking` and `redacted_thinking` from the turns you carry across (their `text` and `tool_use` blocks stay), or send `prefix_mismatch_behavior: "drop_block"` and let the API drop them. Simple compaction (one summary message plus the next user turn, no earlier turns replayed) leaves no thinking behind to fail and is the recommended shape. Server-side [compaction](https://platform.claude.com/docs/en/build-with-claude/compaction) and [context editing](https://platform.claude.com/docs/en/build-with-claude/context-editing) don't count as edits. See [Custom compaction on the client](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#custom-compaction-on-the-client).
320 </Accordion>
321
322 <Accordion title="How do I handle instruction files such as AGENTS.md or CLAUDE.md that change mid-session?">
323 Load them once at session start and keep the top-level `system` prompt and `tools` fixed. When a file changes, append the new version at that point in `messages` instead of editing the original: a [mid-conversation system message](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages) for instructions that come from you as the operator, or content in the next `user` turn for file text you treat as untrusted, which shouldn't carry system-prompt authority. See [Add instructions with a mid-conversation system message](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#add-instructions-with-a-mid-conversation-system-message-not-by-editing-system) and [Limitations](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages#limitations).
324 </Accordion>
325
326 <Accordion title="Can I resume a saved session later, after a restart or the next day?">
327 Yes. A resumed session is an ordinary follow-up request: `system`, `tools`, and the earlier `messages` must match what you last sent byte-for-byte. Persist what you sent and received (the rendered system prompt, the tool definitions, each assistant turn as returned) and replay that, rather than re-rendering from inputs that might have changed since, such as the date, an updated instruction file, or a new tool version. Anything new goes in an appended message. See [Append assistant turns exactly as returned](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#append-assistant-turns-exactly-as-returned).
328 </Accordion>
329
330 <Accordion title="What happens to thinking when the conversation moves from Claude Fable 5.1 to an older model and back?">
331 Keep sending the full history and let the API decide on each request. An older model can't read Claude Fable 5.1's thinking blocks, so the API leaves them out of what that model sees for that one request (no error, not billed, and reported as `model_binding_mismatch` in `input_transformations` when you send the beta header); it never edits your `messages` array, so the blocks stay in your history. When the same history goes back to Claude Fable 5.1, those blocks are readable again, along with the older model's thinking. The reasoning is lost only if your client removes the blocks itself, for example a harness that strips thinking on a model switch or rebuilds the history from what each model used. See [Only for the model that produced it, or a newer one](https://platform.claude.com/docs/en/build-with-claude/thinking#preserved-for-model) for which models read which blocks.
332
333 
334 </Accordion>
335
336 <Accordion title="My harness can route a turn to a non-Claude model. Do those turns invalidate Claude's earlier thinking?">
337 No, provided they're appended after the existing history and nothing earlier changes: an assistant message without thinking blocks is an appended message like any other. Send the other model's output as `text` and `tool_use` content.
338 </Accordion>
339
340 <Accordion title="Can I carry a conversation's reasoning into a new conversation?">
341 Not into a different conversation. A thinking block is usable only behind the exact `system`, `tools`, and `messages` it was produced from, so a branch that replays that history unchanged up to the fork point keeps its thinking, and a conversation that starts from anything else can't use it. Start that one from a summary of the task state (the goal, decisions made, files and results so far, and the next step), as in [simple compaction](https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#custom-compaction-on-the-client).
342 </Accordion>
343</AccordionGroup>
344
299345## Next steps
300346
301347<CardGroup cols={2}>
build-with-claude/task-budgets Changed · +55 / -20 lines
### What counts as a turn ### Worked example: budget counting across requests ### Worked example: budget counting across turns
from line 248
248248</Note>
249249
250250<Warning>
251 **The countdown reflects tokens Claude has processed in the current agentic loop, not tokens you resend between turns.** If your client sends the full conversation history on every follow-up request, your client-side token count may differ from the budget Claude is tracking. If you also decrement `remaining` while resending full history, the model sees an under-reported budget and the countdown drops faster than it should, causing Claude to wrap up earlier than the budget actually allows. Set a generous budget and let the model self-regulate against the countdown rather than trying to mirror it client-side.
251 **The countdown reflects tokens Claude has processed in the current agentic loop, not tokens you resend between requests.** If your client sends the full conversation history on every follow-up request, your client-side token count might differ from the budget Claude is tracking. If you also decrement `remaining` while resending full history, the model sees an under-reported budget and the countdown drops faster than it should, causing Claude to wrap up earlier than the budget actually allows. Set a generous budget and let the model self-regulate against the countdown rather than trying to mirror it client-side.
252252</Warning>
253253
254### Worked example: budget counting across turns
254### What counts as a turn
255255
256The task budget counts what Claude **sees** (thinking, tool calls and results, and text), not what's in your request payload. In an agentic loop your client resends the full conversation on every request, so the payload grows turn over turn, but the budget only decrements by the tokens Claude sees this turn.
256The budget covers one agentic turn, also called an agentic loop: everything Claude does in response to one user message that carries no tool results. A turn can span several requests.
257257
258A user message that carries no tool results starts a new turn with a fresh budget. Today, the countdown still counts earlier turns' history while it remains in the context. A common case is a follow-up after Claude has ended its turn, for example because the budget ran out:
259
260```json
261{ "role": "user", "content": "Continue." }
262```
263
264A user message that contains `tool_result` blocks continues the current turn, because your client is resolving tool calls that are part of that turn:
265
266```json
267{
268 "role": "user",
269 "content": [
270 { "type": "tool_result", "tool_use_id": "toolu_01", "content": "<npm audit output>" }
271 ]
272}
273```
274
275That holds even when the message adds new content alongside the tool results:
276
277```json
278{
279 "role": "user",
280 "content": [
281 { "type": "tool_result", "tool_use_id": "toolu_01", "content": "<npm audit output>" },
282 { "type": "text", "text": "Also check the Dockerfile." }
283 ]
284}
285```
286
287Server-side [compaction](https://platform.claude.com/docs/en/build-with-claude/compaction) during a turn does not reset the budget: tokens the turn consumed before the compaction still count against it. Tokens from before the turn began do not count, even when a compaction at the start of a turn summarizes them. Today, that exclusion applies only to the budget carried across a server-side compaction; earlier turns' history still counts while it remains in the context.
288
289### Worked example: budget counting across requests
290
291The task budget counts what Claude **sees** (thinking, tool calls and results, and text), not what's in your request payload. In an agentic loop your client resends the full conversation on every request, so the payload keeps growing, but the budget only decrements by what is new: the tokens Claude generates and the content it has not seen before. The following example is one [agentic turn](https://platform.claude.com/docs/en/build-with-claude/task-budgets#what-counts-as-a-turn) made of three requests: the first carries the user message, and the next two each resend the history with a tool result appended.
292
258293Consider a loop with `task_budget: {type: "tokens", total: 100000}` and a single `bash` tool.
259294
260**Turn 1.** You send the initial request:
295**Request 1.** You send the initial request:
261296
262297```json
263298{
from line 322
287322}
288323```
289324
290Suppose this assistant turn (thinking plus the tool call) totals 5,000 generated tokens. The countdown Claude saw during generation ended near `remaining` ≈ 95,000.
325Suppose this assistant message (thinking plus the tool call) totals 5,000 generated tokens. The countdown Claude saw during generation ended near `remaining` ≈ 95,000.
291326
292**Turn 2.** Your client runs the tool, then resends the full history with the tool result appended:
327**Request 2.** Your client runs the tool, then resends the full history with the tool result appended:
293328
294329```json
295330{
from line 356
321356}
322357```
323358
324The resent turn-1 user and assistant messages are not counted again, but the 2,800-token tool result is new content Claude sees this turn and counts against the budget. Claude spends another 4,000 tokens on thinking and a second tool call (`grep -rn "eval(" src/`). The countdown ends near `remaining` ≈ 88,200.
359The resent messages from request 1 are not counted again, but the 2,800-token tool result is new content and counts against the budget. Claude spends another 4,000 tokens on thinking and a second tool call (`grep -rn "eval(" src/`). The countdown ends near `remaining` ≈ 88,200.
325360
326**Turn 3.** Full history resent again with the second tool result (1,200 tokens of grep output) appended. Claude writes a 6,000-token final findings report and stops with `stop_reason: "end_turn"`. `remaining` ≈ 81,000.
361**Request 3.** Full history resent again with the second tool result (1,200 tokens of grep output) appended. Claude writes a 6,000-token final findings report and stops with `stop_reason: "end_turn"`. `remaining` ≈ 81,000.
327362
328Putting the three turns side by side makes the distinction between payload size and budget spend explicit:
363Putting the three requests side by side makes the distinction between payload size and budget spend explicit:
329364
330| Turn | Request payload (approx. input tokens you sent) | Tokens counted against budget this turn | Budget `remaining` after |
365| Request | Request payload (approx. input tokens you sent) | Tokens counted against budget this request | Budget `remaining` after |
331366| --------- | ----------------------------------------------- | --------------------------------------------------------- | ------------------------ |
332367| 1 | \~20 | 5,000 (thinking + `tool_use`) | \~95,000 |
333| 2 | \~7,800 (turn 1 history + tool result) | 6,800 (2,800 tool result + 4,000 thinking and `tool_use`) | \~88,200 |
368| 2 | \~7,800 (messages from request 1 + tool result) | 6,800 (2,800 tool result + 4,000 thinking and `tool_use`) | \~88,200 |
334369| 3 | \~13,000 (full history + second tool result) | 7,200 (1,200 tool result + 6,000 `text`) | \~81,000 |
335370| **Total** | **\~20,820 sent across requests** | **19,000 counted against budget** | N/A |
336371
337Your client sent the turn-1 user message three times and the turn-1 assistant message twice, but each was counted once. The budget spent 19,000 of 100,000 tokens, even though the cumulative payload your client transmitted was larger and the prompt-cached input on turns 2 and 3 was larger still.
372Your client sent the original user message three times and the first assistant message twice, but each was counted once. The budget spent 19,000 of 100,000 tokens, even though the cumulative payload your client transmitted was larger and the prompt-cached input on requests 2 and 3 was larger still.
338373
339374### Carrying a budget across compaction with `remaining`
340375
341If your agentic loop compacts or rewrites context between requests (for example, by summarizing earlier turns), the server has no memory of how much budget was spent before compaction. Pass `remaining` on the next request so the countdown continues from where you left off rather than resetting to `total`:
376If your own code compacts or rewrites the message history between requests (for example, by summarizing earlier messages), the server has no memory of how much budget was spent before compaction. Pass `remaining` on the next request so the countdown continues from where you left off rather than resetting to `total`:
342377
343378<CodeGroup exclude="shell">
344379 ```python Python
from line 476
441476
442477In this example, the tokens spent before compaction are the usage of all the messages you have removed from the history so far, measured as in [Measure your current usage](https://platform.claude.com/docs/en/build-with-claude/task-budgets#measure-your-current-usage). Leave out anything still present in the messages you send, including any summary you added, because the server counts those tokens itself. Update this figure only when you replace the history this way; don't decrement it per request. Pass the resulting `remaining` on every request, not only the one that compacts.
443478
444For loops that resend the full uncompacted history on every turn, omit `remaining` and let the server track the countdown.
479For loops that resend the full uncompacted history on every request, omit `remaining` and let the server track the countdown.
445480
446481## Changing the budget mid-conversation
447482
from line 631
596631* **`max_tokens`:** Orthogonal to task budgets. `max_tokens` is a hard per-request cap on generated tokens, while `task_budget` is an advisory cap across the full agentic loop (potentially spanning many requests). At `xhigh` or `max` effort, set `max_tokens` to at least 64k to give Claude room to think and act on each request.
597632* **[Effort](https://platform.claude.com/docs/en/build-with-claude/effort):** Effort controls how deeply Claude reasons per step. Task budgets control how much total work Claude does across an agentic loop. The two are complementary: effort tunes depth, task budgets tune breadth.
598633* **[Adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/thinking):** Task budgets include thinking tokens in the count, so adaptive thinking scales down as the budget depletes.
599* **[Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching):** The budget-countdown marker is injected server-side per turn, so it does not match across requests. If your client decrements `task_budget.remaining` on each follow-up request, the changed value invalidates any cache prefix that contains it. To preserve caching, set the budget once on the initial request and let the model self-regulate against the server-side countdown rather than mutating the budget client-side.
634* **[Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching):** The budget-countdown marker is injected server-side on each request, so it does not match across requests. If your client decrements `task_budget.remaining` on each follow-up request, the changed value invalidates any cache prefix that contains it. To preserve caching, set the budget once on the initial request and let the model self-regulate against the server-side countdown rather than mutating the budget client-side.
600635
601636## Feature support
602637
build-with-claude/token-counting Changed · +21 / -27 lines
from line 790
790790 -H "content-type: application/json" \
791791 -H "anthropic-version: 2023-06-01" \
792792 -d '{
793 "model": "claude-sonnet-4-6",
793 "model": "claude-opus-5",
794794 "thinking": {
795 "type": "enabled",
796 "budget_tokens": 16000
795 "type": "adaptive"
797796 },
798797 "messages": [
799798 {
from line 823
824823
825824 ```bash CLI
826825 ant messages count-tokens <<'YAML'
827 model: claude-sonnet-4-6
826 model: claude-opus-5
828827 thinking:
829 type: enabled
830 budget_tokens: 16000
828 type: adaptive
831829 messages:
832830 - role: user
833831 content: Are there an infinite number of prime numbers such that n mod 4 == 3?
from line 847
849847 client = anthropic.Anthropic()
850848
851849 response = client.messages.count_tokens(
852 model="claude-sonnet-4-6",
853 thinking={"type": "enabled", "budget_tokens": 16000},
850 model="claude-opus-5",
851 thinking={"type": "adaptive"},
854852 messages=[
855853 {
856854 "role": "user",
from line 879
881879 const client = new Anthropic();
882880
883881 const response = await client.messages.countTokens({
884 model: "claude-sonnet-4-6",
885 thinking: {
886 type: "enabled",
887 budget_tokens: 16000
888 },
882 model: "claude-opus-5",
883 thinking: { type: "adaptive" },
889884 messages: [
890885 {
891886 role: "user",
from line 923
928923
929924 var parameters = new MessageCountTokensParams
930925 {
931 Model = Model.ClaudeSonnet4_6,
932 Thinking = new ThinkingConfigEnabled(budgetTokens: 16000),
926 Model = Model.ClaudeOpus5,
927 Thinking = new ThinkingConfigAdaptive(),
933928 Messages =
934929 [
935930 new()
from line 970
975970 )
976971
977972 response, err := client.Messages.CountTokens(context.TODO(), anthropic.MessageCountTokensParams{
978 Model: anthropic.ModelClaudeSonnet4_6,
979 Thinking: anthropic.ThinkingConfigParamOfEnabled(16000),
973 Model: anthropic.ModelClaudeOpus5,
974 Thinking: anthropic.ThinkingConfigParamUnion{
975 OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
976 },
980977 Messages: []anthropic.MessageParam{
981978 anthropic.NewUserMessage(anthropic.NewTextBlock("Are there an infinite number of prime numbers such that n mod 4 == 3?")),
982979 anthropic.NewAssistantMessage(thinkingBlock, textBlock),
from line 992
995992 import com.anthropic.models.messages.MessageTokensCount;
996993 // ...
997994 import com.anthropic.models.messages.ThinkingBlockParam;
995 import com.anthropic.models.messages.ThinkingConfigAdaptive;
998996 // ...
999997 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
1000998
from line 1015
10171015 );
10181016
10191017 MessageCountTokensParams params = MessageCountTokensParams.builder()
1020 .model(Model.CLAUDE_SONNET_4_6)
1021 .enabledThinking(16000)
1018 .model(Model.CLAUDE_OPUS_5)
1019 .thinking(ThinkingConfigAdaptive.builder().build())
10221020 .addUserMessage("Are there an infinite number of prime numbers such that n mod 4 == 3?")
10231021 .addAssistantMessageOfBlockParams(assistantBlocks)
10241022 .addUserMessage("Can you write a formal proof?")
from line 1054
10561054 'content' => 'Can you write a formal proof?'
10571055 ]
10581056 ],
1059 model: 'claude-sonnet-4-6',
1060 thinking: [
1061 'type' => 'enabled',
1062 'budget_tokens' => 16000
1063 ],
1057 model: 'claude-opus-5',
1058 thinking: ['type' => 'adaptive'],
10641059 );
10651060
10661061 echo json_encode($response);
from line 1065
10701065 client = Anthropic::Client.new
10711066
10721067 response = client.messages.count_tokens(
1073 model: "claude-sonnet-4-6",
1068 model: "claude-opus-5",
10741069 thinking: {
1075 type: "enabled",
1076 budget_tokens: 16000
1070 type: "adaptive"
10771071 },
10781072 messages: [
10791073 {
agents-and-tools/tool-use/code-execution-tool Changed · +1 / -1 lines
from line 888
888888
889889### Content Credentials on generated files
890890
891On the Claude API, supported image and video files that Claude produces in the code execution sandbox carry [C2PA](https://c2pa.org/) Content Credentials when you download them through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files). [Supported formats](https://opensource.contentauthenticity.org/docs/sdk-repos/c2pa-python/docs/supported-formats/) include PNG, JPEG, GIF, WebP, TIFF, HEIC, AVIF, SVG, MP4, and MOV. The credential is a cryptographically signed manifest embedded in the file's metadata. It identifies Anthropic as the issuer, carries a timestamp, and records the action description "Claude provided this file at the request of a user and may have created or modified the file contents."
891On the Claude API, supported image, video, and audio files that Claude produces in the code execution sandbox carry [C2PA](https://c2pa.org/) Content Credentials when you download them through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files). [Supported formats](https://opensource.contentauthenticity.org/docs/sdk-repos/c2pa-python/docs/supported-formats/) include PNG, JPEG, GIF, WebP, TIFF, HEIC, AVIF, SVG, MP4, MOV, MP3, WAV, FLAC, and M4A. The credential is a cryptographically signed manifest embedded in the file's metadata. It identifies Anthropic as the issuer, carries a timestamp, and records the action description "Claude provided this file at the request of a user and may have created or modified the file contents."
892892
893893Signing requires no changes to your requests or response handling, and the manifest records nothing about you, your organization, or your request. The file's visible content is unchanged. The manifest adds a few kilobytes, so the downloaded file's size and checksum differ from the file as it exists inside the container. Text files, PDFs, and office documents are not signed because they are not supported formats for signing. Files you upload are stored as-is, including any Content Credentials they already carry.
894894
build-with-claude/files Changed · +1 / -1 lines
from line 940
940940 A file is downloadable only when its metadata shows `"downloadable": true`, which is the case for files created by skills or the code execution tool. Downloading a file you uploaded returns a 400 error.
941941</Note>
942942
943On the Claude API, supported image and video files that Claude produces with the code execution tool, including files created by skills, carry signed C2PA Content Credentials when you download them. See [Content Credentials on generated files](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool#content-credentials-on-generated-files) for what the credential contains and how to verify it.
943On the Claude API, supported image, video, and audio files that Claude produces with the code execution tool, including files created by skills, carry signed C2PA Content Credentials when you download them. See [Content Credentials on generated files](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool#content-credentials-on-generated-files) for what the credential contains and how to verify it.
944944
945945## File storage and limits
946946
models/fable-5-1/whats-new-fable-5-1 Changed · +1 / -1 lines
from line 354
354354
355355### Content provenance
356356
357Text generated by Claude Fable 5.1 and Claude Mythos 5.1 carries Anthropic's statistical text watermark on every platform where the model is available. Supported image and video files Claude produces (through the [code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool), for example) carry signed [C2PA](https://c2pa.org/) Content Credentials when you retrieve them through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) on the Claude API.
357Text generated by Claude Fable 5.1 and Claude Mythos 5.1 carries Anthropic's statistical text watermark on every platform where the model is available. Supported image, video, and audio files Claude produces (through the [code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool), for example) carry signed [C2PA](https://c2pa.org/) Content Credentials when you retrieve them through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) on the Claude API.
358358
359359The watermark doesn't change the meaning, quality, or readability of the output. It adds no tokens or hidden characters, carries no information about you or your organization, and needs no changes to your requests or responses. For background, see [How Claude marks AI-generated content](https://support.claude.com/en/articles/16266773-how-claude-marks-ai-generated-content) and [How Claude's text watermark works](https://www.anthropic.com/news/claude-text-watermark).
360360
release-notes/overview Changed · +1 / -1 lines
from line 21
2121* Per-message effort changes are in beta on Claude Fable 5.1, Claude Mythos 5.1, and Claude Opus 5 on the Claude API. Add a `role: "system"` message with `output_config.effort` inside `messages` to change effort for later turns while preserving the prompt cache. Include the `mid-conversation-output-config-2026-07-01` beta header in your requests. See [Per-message effort](https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta).
2222* [Turn-scoped system messages](https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) are in beta (`mid-conversation-system-clear-at-2026-08-21` header). Set `clear_at: "next_user_message"` on a mid-conversation `role: "system"` message and it renders for the current turn only, then stays in the history at no token cost. Per-turn reminders don't accumulate and don't invalidate the prompt cache or later thinking blocks.
2323* `thinking.display` accepts a third value, `"updates"`, in beta (`thinking-display-updates-2026-08-18` header). Reasoning comes back with an empty `thinking` field, as under `"omitted"`, and the short progress updates that Claude Fable 5.1, Claude Mythos 5.1, and Claude Fable 5 write between tool calls come back as text, at most one `thinking` block before a tool call. See [Progress updates between tool calls](https://platform.claude.com/docs/en/build-with-claude/thinking#progress-updates).
24* Text generated by Claude Fable 5.1 and Claude Mythos 5.1 carries Anthropic's text watermark, and supported image and video files that Claude produces through the [code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) carry C2PA Content Credentials when you retrieve them through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) on the Claude API. Marking requires no changes to your requests or response handling.
24* Text generated by Claude Fable 5.1 and Claude Mythos 5.1 carries Anthropic's text watermark, and supported image, video, and audio files that Claude produces through the [code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool) carry C2PA Content Credentials when you retrieve them through the [Files API](https://platform.claude.com/docs/en/build-with-claude/files) on the Claude API. Marking requires no changes to your requests or response handling.
2525* Like Claude Fable 5, both models require 30-day data retention and aren't available under zero data retention unless expressly authorized by Anthropic. See [Model-specific data retention requirements](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
2626* The guides for the Claude Enterprise endpoints of the [Admin API](https://platform.claude.com/docs/en/api/admin) ([user management](https://platform.claude.com/docs/en/manage-claude/user-management) and [spend limits](https://platform.claude.com/docs/en/manage-claude/spend-limits-api)), the [Claude Enterprise Analytics API](https://platform.claude.com/docs/en/manage-claude/analytics-api), and the [Compliance API](https://platform.claude.com/docs/en/manage-claude/compliance-api) now show the `anthropic-version` header; send it on every request to these endpoints, as in the rest of the Claude API. See [API versions](https://platform.claude.com/docs/en/api/versioning).
2727