Claude Fable 5.1 Per-Message Effort and Mid-Session Tool Changes: Three Beta Controls That Don't Break Your Cache

One thing operators running long agentic sessions on Claude have not been able to do cleanly is change behavior mid-conversation without paying a cache penalty. If you edit the top-level system field to add a new constraint, you invalidate the cached prefix — everything before that edit gets repriced at standard input rates. Same problem if you modify the tools array after turn three to remove a dangerous capability. And if you want the model to spend fewer tokens on a quick lookup but more tokens on a complex analysis in the same session, you either accept a flat effort level or you break caching to reconfigure.

The September 1 Claude API release addresses all three of these situations with beta controls on Claude Fable 5.1, Mythos 5.1, and Opus 5. They share a common design goal: let the operator change what matters without touching the prefix that the cache already holds.

Three betas, one shared principle

The three features are distinct but architecturally related.

Per-message effort (beta header: mid-conversation-output-config-2026-07-01) lets you set output_config.effort inside a role: "system" message anywhere in the conversation. The change applies from that point forward. The prefix that came before it — system prompt, tool definitions, early conversation turns — stays cached. The request looks like this:

messages = [
    {"role": "user", "content": "Summarize this codebase quickly."},
    # inject a system message to drop effort for the next turn
    {"role": "system", "content": [{"type": "output_config", "output_config": {"effort": "low"}}]},
    {"role": "assistant", "content": "..."},
    {"role": "user", "content": "Now do a thorough security audit of the auth module."},
    # raise effort back up for the complex turn
    {"role": "system", "content": [{"type": "output_config", "output_config": {"effort": "high"}}]},
]

Without this, operators either lock the session to a single effort level for its lifetime, or they start a new session for each effort tier — forfeiting the cache hits from a shared long prefix.

Turn-scoped system messages (beta header: mid-conversation-system-clear-at-2026-08-21) solve a related problem: per-turn reminders that accumulate. A common agentic pattern injects a short reminder at each turn — "You are reviewing file X, focus on auth." If you do that with a regular mid-conversation system message, those reminders pile up in the history, costing tokens on every subsequent request. With clear_at: "next_user_message", the message is presented to the model for the current turn, then stays in history at zero token cost. It does not invalidate the cache, and it does not accumulate.

Mid-conversation tool changes (beta header: mid-conversation-tool-changes-2026-07-01) are the tools equivalent. The tools array normally sits at the earliest point in the hashed request prefix — modifying it invalidates the cache for the entire conversation. The beta lets you declare all tools upfront in tools, mark some with defer_loading: true to withhold them until needed, and then surface or withdraw them mid-session using tool_addition and tool_removal blocks inside a role: "system" message. The tools array itself never changes. The prefix stays intact.

# Declare all tools upfront; dangerous one is deferred
tools = [
    {"name": "read_file", ...},
    {"name": "write_file", ..., "defer_loading": True},  # withheld until explicitly added
]

# Later, when the agent needs to write:
messages.append({
    "role": "system",
    "content": [
        {"type": "tool_addition", "tool": {"type": "tool_reference", "name": "write_file"}}
    ]
})

The operator routing angle

These three features matter most for operators running sessions with long shared prefixes — a large codebase loaded into context, a multi-agent workflow with many turns, or an enterprise session with an extended system prompt. At Fable 5.1's $0.25/MTok cache read rate (0.025× the $10/MTok base input rate), keeping that prefix cached across many turns drives real cost savings.

The failure mode before these betas was: operators who needed dynamic behavior made changes that invalidated the cache, then paid standard input rates on the next turn for a prefix that had previously been cached. For a 500k-token system prompt on Fable 5.1, a single cache miss costs $5.00 in input reads instead of $0.125 as a cache hit. In a session with ten such accidental invalidations, that is $48.75 in unnecessary spend.

The cross-provider picture matters too. Amazon Bedrock and Google Cloud now support all three features on the same models. Azure Foundry is not listed in the current docs — operators using Foundry should verify support before enabling the beta headers. Standard Claude API on Anthropic, Bedrock, and Vertex AI are confirmed.

Gateway operators have a specific concern: these beta headers must pass through untouched. A proxy that strips unknown anthropic-beta headers will silently cause the beta behavior to fail — the request still succeeds, but per-message effort changes are ignored, turn-scoped system messages accumulate instead of expiring, and deferred tools are never surfaced. The failure is behavioral, not a 4xx error, so it may go undetected in monitoring. Verify that your gateway forwards all anthropic-beta headers from the upstream client through to the Anthropic API.

What changes in your request construction

Before these betas, a gateway or orchestration layer that needed to change effort or tools between turns had three options: start a new session, accept the cache penalty, or implement ad-hoc workarounds. Now there is a fourth option that costs nothing in cache terms.

The migration path for effort is straightforward. Move the top-level output_config.effort out of the request root and inject it as a mid-conversation role: "system" message before the first user turn. Then inject new effort values as the session progresses. The top-level parameter still works and remains the default — per-message effort is additive, not a replacement.

For tool changes, the shift is more structural. You declare the full tool universe in tools upfront, using defer_loading: true for anything that should not be offered immediately. The orchestration layer then tracks which tools are currently active and injects tool_addition/tool_removal blocks at the appropriate turns. If your current architecture modifies the tools array between requests, the migration path is to declare once and switch to tool_addition/tool_removal — the behavioral result is the same, but the prefix is preserved.

All three features require the relevant beta header. If you are using SDK-level abstractions, check whether your SDK version forwards beta headers correctly — older pinned versions may not. The anthropic-beta header accepts a comma-separated list, so you can enable multiple betas in one header.

What to watch

These are betas, and Anthropic has not committed to keeping the current request shapes stable before GA. The mid-conversation-output-config-2026-07-01 date suffix in the header name follows the pattern of earlier betas that became GA with a different header or no header. Watch the platform release notes for GA promotion signals.

One risk for multi-provider routing layers: if you route the same session to a fallback provider (say, Bedrock) mid-conversation, and Bedrock is on a different SDK version or has delayed beta rollout, the provider swap may change behavior on per-message effort or deferred tools in ways that are hard to detect. Consider treating sessions that use these betas as single-provider sessions until GA, or at minimum test the fallback provider's handling before enabling.

For teams using Claude Code with a gateway pointed at the Anthropic API: Claude Code's own session management uses prompt caching and mid-conversation system messages internally. These new betas are API-level controls that apply to direct API users building their own orchestration, not to Claude Code's managed sessions. The two layers do not interfere, but they are separate.

The full docs for per-message effort are at /docs/en/build-with-claude/effort and for mid-conversation tool changes at /docs/en/build-with-claude/mid-conversation-system-messages on the Anthropic platform docs.