Claude message threads: faster long sessions, and a feature that isn't ZDR eligible
Anthropic's message threads beta keeps a conversation on the server between turns. What it changes for latency, cost, proxies and data-retention commitments.
On 2 November 2026 Anthropic put message threads into public beta on the Messages API. A thread lets a client send a long conversation once and then send only the new turns, while the API keeps the rest in memory between requests. For long agent sessions that means smaller requests and a lower time to first token. It also means the provider holds the conversation between calls, and the documentation is explicit that this feature is not eligible for zero data retention (ZDR).
Both halves of that matter. This article covers what threads do, what they do not change, and what teams with data-retention commitments or a proxy in the request path should check.
How a thread works
Without a thread, every turn of an agent loop uploads the whole conversation again, and the API validates and tokenises all of it again. With a thread, the first request carries the full conversation plus thread: {"type": "create"}, and each later request carries only the new messages, {"type": "continue"} and the ID of the previous response. The feature needs the message-threads-2026-08-12 beta header.
The rules are strict, and they shape how a client has to be written:
- The system prompt and tools are set once. They go in the create request only; sending them on a continue request returns a 400 error.
- Fixed fields cannot change mid-thread. The model, tool choice, thinking settings, MCP servers (apart from their tokens), context management, output configuration, container skills, top-level cache control and the set of beta headers are fingerprinted. A continue request that changes any of them fails with
thread_fingerprint_mismatch. - Threads are append-only. Each response ID can be continued once, so you cannot branch a thread or replace early turns with a summary. To compact, you start a new thread from a summary you write yourself.
- Threads are short-lived and best-effort. A thread expires 5 minutes after its last request and is deleted no more than an hour after its last use. If it is gone, the API returns
thread_not_foundand the client must replay the full conversation. The documentation says plainly that your application remains the source of truth.
There is no API to list, read or delete a thread. Requests in a thread have to come from the same API key and workspace that created it (on Claude Platform on AWS, the same IAM role or user).
Several features do not work with threads: the Message Batches API, token counting, the compaction parameter and most context editing. Organisations with HIPAA readiness or inference hooks turned on cannot use them.
What it changes, and what it doesn't
The gain is latency. Anthropic's announcement says threads are on by default for most Claude Code users, and that requests of 500,000 to 1 million tokens see median time to first token drop by about 35%. Anthropic does not say which Claude Code users are excluded, and at the time of writing we could not find an entry about threads in the Claude Code changelog, so treat "most" as unspecified.
The cost does not move. Pricing and rate limits are unchanged, and the announcement is clear that Claude still reads the full conversation on every turn, so token usage stays the same. A thread is not a prompt cache, either: the documentation says a thread does not cache your prompt for you, and caching works as it does without one, with you choosing where the breakpoints go. If your bill is driven by long contexts, the levers are still the ones covered in our articles on prompt caching and on idle compaction in Claude Code.
The data-handling question
The documentation's data-retention section is short and specific. Message threads are not ZDR eligible; using them does not affect your use of other ZDR-eligible features. The API holds a thread in memory, encrypted under a server-managed key, never writes it to durable storage, and deletes it no more than an hour after its last use. A thread contains the conversation sent to the model, the system prompt and tools from the create request, and a fingerprint of the fixed fields. Files are held by reference. Threads are not HIPAA eligible either.
An hour in encrypted memory is a modest exposure compared with ordinary log retention, but "modest" is not the test a contract or a data-protection assessment applies. If your organisation has told customers, auditors or its own privacy team that model inputs are not retained by the provider, a client that turns threads on changes that statement, even if only for an hour at a time.
A related detail: after a fallback to another model, the API may route later turns straight to the fallback model for about an hour. The documentation says this sticky routing does not apply where an organisation or workspace uses zero data retention or customer-managed encryption keys.
Proxies and gateways
Many teams put a proxy or gateway between their tools and the provider for budgets, logging or routing. Threads interact with that layer in three ways:
- The proxy must pass the
threadfield and the beta header through unchanged. One that drops unknown fields or rewrites headers will silently turn every request back into a full upload, or cause errors on continue requests. - Swapping models mid-conversation breaks threads. The model is a fixed field, so a routing rule that changes the model between turns will trigger fingerprint mismatches. Routing that decides once per conversation is compatible; routing that decides per request is not.
- Request logs get thinner. With threads, each logged request holds only the new turns. If your audit or evaluation process reconstructs conversations from proxy logs, it now needs the first request of each thread as well.
What it means for engineering and security leaders
Threads are a sensible optimisation for interactive agent work, and the latency figures will make them attractive. The decision is not purely technical, though. Before they are used widely, someone should confirm that the feature fits the organisation's data-handling commitments, and someone should confirm that the request path supports it.
Practical takeaways
- Check your ZDR position first. If you rely on zero data retention, decide explicitly whether threads are acceptable, and write that decision down.
- Ask how your tools use threads. Anthropic says Claude Code uses them by default for most users, and the SDK tool runner uses a thread by default. Confirm what applies to your accounts.
- Test your proxy with a continue request. Make sure it forwards the field and header, and that any model routing is decided once per conversation.
- Keep the full conversation client-side. The API can drop a thread at any time, and replaying is the documented recovery.
- Do not expect a smaller bill. Measure time to first token if latency matters; budget as before.
- Remember it is a beta. The header is dated and behaviour can change before general availability.