Anthropic added message threads to the Claude Messages API in public beta. A thread keeps a conversation on the server for a short time, so an agent sends the full history once and then only the new messages on each later turn. The change is listed in the Claude Platform release notes under November 2, 2026.
The goal is lower latency in long sessions, not lower cost. Anthropic's announcement says Claude still reads the full conversation on every turn, so token usage stays the same, and standard token rates and existing rate limits apply.
What problem it addresses
A coding agent can make hundreds of requests in one session. Without a thread, each request resends every earlier message and tool result. Anthropic says that once a conversation reaches hundreds of thousands of tokens, resending all of it adds time before Claude starts responding.
The documentation adds that without a thread, the API also validates and tokenizes the whole conversation again on every turn. With a thread, most of that work covers only the new turn.
Anthropic gives one performance figure. With message threads on by default for most Claude Code users, requests with 500k to 1M tokens see median time to first token drop by about 35%, according to the announcement. Anthropic adds that the more context an agent carries, the more message threads can reduce time to first token.
How a thread works
You add one parameter, thread, to a Messages API request, and send the beta header message-threads-2026-08-12 on every request of the thread.
- Create. The first request carries the full conversation, the system prompt and the tools, plus
"thread": {"type": "create"}. The API stores the conversation, including Claude's reply, under the responseid. - Continue. Later requests send only the new messages and
"thread": {"type": "continue", "previous_message_id": ...}with the previous responseid.systemandtoolsmust be left out, and sending either one returns a 400 error. - Replay. A thread is best effort. If the API can no longer continue it, the request returns a 404 error, and the client sends the full conversation again in a new create request.
Each response id can be continued once, so an agent always continues from its latest response. To edit or branch an earlier message, it starts a new thread.
The documentation says the client stays the source of truth. Anthropic tells developers to keep their own copy of every message and to build the replay path from the start, because no response says whether the API stored that turn. The Python, TypeScript and other SDKs include a thread helper that does the replay automatically and keeps the conversation in memory only while the helper object exists.
What stays fixed
Some fields are set when the thread is created and must match on every later request, including model, tool_choice, thinking and the top-level cache_control. A different value returns a 400 error with the code thread_fingerprint_mismatch. To change one of them, the developer starts a new thread. Fields such as max_tokens, stop_sequences and stream can change from turn to turn.
Prompt caching still works as it does without a thread, and the developer chooses where the cache breakpoints go. A request that uses a thread can carry at most four cache_control breakpoints, with the top-level one counting as one.
Streaming works too, but the documentation says to continue from a response only after the message_stop event arrives. After a response with stop_reason: "refusal", developers should not continue the thread and should start a new one.
Retention and limits
Threads are held in memory, encrypted under a server-managed key, and are not written to durable storage. A thread expires 5 minutes after its last request, and the API deletes it no more than 1 hour after its last use. There is no API to list, read or delete a thread.
Message threads are not eligible for zero data retention, and they are not available to organizations that have HIPAA readiness enabled. The documentation also lists features that threads do not support:
- Message Batches
- Token counting, which needs the full conversation sent without
thread - Compaction on demand
- Context editing, except
clear_thinking_20251015withkeep: "all" - Organizations that have inference hooks turned on
Threads are in beta on every model. They are available on the Claude API, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) and Claude in Microsoft Foundry. The documentation says message threads are different from session threads in Claude Managed Agents.
Why it matters
In Anthropic's words, each tool result or file edit adds to a coding agent's conversation. Its own example workloads are long coding sessions, computer use agents whose screenshots stay with the thread, and document or image heavy workflows. For those, a smaller request means less upload and less repeated validation before the model starts.
The trade is more state to manage. Developers get a lower time to first token, but they must handle expiry after 5 minutes of inactivity, one-time continuation of each response, and a replay path. Organizations that need zero data retention, or that have HIPAA readiness enabled, cannot use the feature.
The request size limits are a related change. On October 28 Anthropic raised the Messages API request limit from 32 MB to 128 MB on the first-party Claude API, which we covered in Claude API Raises Request Limit to 128 MB, Adds Cost API. For background on tokens and context, see the AI glossary.
