Quick Answer
Anthropic opened message threads in public beta on the Messages API on 2 November 2026, letting an agent send the full conversation once and then send only new messages on later turns. On requests with 500,000 to 1 million tokens, median time to first token falls by about 35 percent for most Claude Code users, while token usage, pricing, and rate limits stay exactly the same, because Claude still reads the full conversation on every turn.
Key takeaways:
- Message threads entered public beta on 2 November 2026 on the Messages API, and are already on by default for most Claude Code users.
- The first request sends the full conversation, system prompt, and tools with a thread parameter. Later requests send only new messages plus the previous response ID.
- On 500,000 to 1 million token requests, median time to first token drops by about 35 percent, and the median request size in long conversations drops from about 800 KB to 1.8 KB.
- Token billing does not drop, because Claude still processes the full conversation each turn. Prompt caching still needs to be requested separately.
- Threads are best effort, held in encrypted memory, never written to disk, and expire 5 minutes after the last request. Your app must keep its own copy and replay the full conversation if a thread is gone.
- The beta is not eligible for zero data retention or HIPAA use, and it does not work with Message Batches, token counting, on demand compaction, or most context editing.
What problem do message threads solve?
Until now, a long running agent had to resend the entire conversation on every turn: the system prompt, every earlier message, every tool result, and every screenshot in a computer use session. The longer the session ran, the larger each request became, and the longer the user waited before Claude started answering. That wait is measured as time to first token, the gap between sending a request and seeing the first word of the reply. Message threads change what travels over the wire, not what Claude thinks about. The first request still sends the full conversation, and Anthropic stores that conversation under the response ID. Later requests send only what is new, plus that ID, and the API reconstructs the full conversation on the server before calling the model. The client sends far less data, so the first token arrives sooner, especially on very long sessions where the resend was the bottleneck. Anthropic's own example makes the scale clear. In long conversations, the median request went from about 800 KB to 1.8 KB once threads were used. That is not a small optimisation. It is the difference between uploading a large document on every turn and uploading a short note, while Claude still sees the whole document on the server side.
What does the 35 percent number actually mean?
The 35 percent figure is specific, and it should not be generalised beyond what Anthropic said. It is the drop in median time to first token on requests with 500,000 to 1 million tokens, with message threads on by default for most Claude Code users. It is not a claim that every Claude request gets 35 percent faster, and it is not a claim about total response time, only about the wait before the first token appears. Short conversations will see little or no benefit, because there is little conversation to resend in the first place. The benefit grows with session length, which is why Anthropic names long running coding agents, computer use agents whose screenshots stay with the thread, and document and image heavy workflows as the intended users. If your agent runs in short, fresh sessions, threads will not transform it. If your agent runs for hours on one task, threads remove a real, repeated cost in waiting time. It is also important to separate latency from billing, because the two are easy to confuse here. The client sends less, but Claude still reads the full conversation on every turn, so token consumption, pricing, and rate limits are unchanged. A developer who expects a lower API bill from threads will be disappointed. The saving is in waiting time and in upload bandwidth, not in tokens. Prompt caching is a separate feature, and it still needs to be requested explicitly if you want the caching discount on repeated content.
How do you use message threads as a developer?
For Claude Code users, there is nothing to install for this change in the usual sense. Anthropic says threads are on by default for most Claude Code users, with no minimum client version named, and the public changelog does not list a threads release to update to. If you use Claude Code and you run long sessions, you should already be getting the benefit on the server side. Updating the CLI does no harm, but it is not the step that turns threads on. For your own agent on the Messages API, the setup is small but exact. You add a thread parameter to the first request, which includes the full conversation, system prompt, and tools, and you add the beta header message-threads-2026-08-12. Later requests include only new messages and the previous response ID. The official SDKs provide a helper that creates and continues threads, adds the header, keeps the conversation in memory, and replays the full conversation once for specified continuation errors. Streaming needs one extra care. For streaming responses, your client must wait for the message_stop event before continuing from a response ID, because an earlier continue request can return a 404 error. That is a small implementation detail, but it is the kind of detail that breaks a demo if you ignore it. Build the wait into your streaming loop from the start, rather than adding it after you see 404 errors in production.
Where is the beta available, and where is it not?
The beta covers four surfaces: the native Claude Platform, Claude Platform on AWS, Claude in Microsoft Foundry, and Claude Models on Google Cloud under Anthropic management. It works with every model, according to Anthropic, which means you do not need to switch models to use it. Amazon Bedrock is not on the official list in the coverage checked, so Bedrock users should not assume threads are available there until Anthropic says so. The limits list is longer than the availability list, and it decides whether threads fit your app. There is no API to list, read, or delete threads. Threads do not support Message Batches, token counting, compaction on demand, or most context editing. They are unavailable to organisations with Inference hooks enabled. They are not eligible for zero data retention use, and they are not eligible for HIPAA use, although the feature does not affect eligibility for other zero data retention features. If your app depends on any of those features, threads are not a drop in addition yet, and you should wait for a later beta or general release that covers your case. | Aspect | With message threads | Without message threads | | What the client sends after setup | Only new messages plus the previous response ID | The full conversation, system prompt, tools, and tool results every turn | | Median request size in long conversations, as reported by Anthropic | About 1.8 KB | About 800 KB | | Median time to first token, 500,000 to 1 million tokens | About 35 percent lower | Baseline | | Token billing and rate limits | Unchanged, Claude still reads the full conversation | Unchanged | | Thread lifetime | Best effort, expires 5 minutes after the last request | No thread to expire, you resend each time | | Storage | Encrypted memory only, never written to disk, deleted no more than 1 hour after last use | Your own storage, as you design it | | Works with | All Claude models on the four listed surfaces | All models, all surfaces |
What happens when a thread expires?
Threads expire 5 minutes after their last request, and each response the API stores restarts that period. That sounds generous for an active agent, but it is short for a human in the loop workflow where a person reads a result, thinks, and replies 10 minutes later. When a thread expires, continuing from its response ID fails, and your app must resend the full conversation to start a new thread. That is why Anthropic's design rule is blunt: your application must still preserve its own conversation history and maintain a full conversation replay path, even when routine turns contain only new messages. Threads are an optimisation on top of a correct, self sufficient client, not a replacement for one. An app that throws away its own copy because the server holds a thread will break the first time a thread expires, a server restarts, or a thread is refused for any reason. The same caution applies to error handling. Threads are best effort, which means the API does not guarantee a thread will still be there when you ask for it. Your code should treat a missing thread as a normal event, replay the full conversation, and continue, rather than treating it as a fatal error. That pattern is familiar to anyone who has built on caches: the cache makes the common case fast, but the source of truth stays with you.
Should you adopt the beta now?
Adopt it now if you build long running agents on the Messages API and you control the client, because the change is small, the latency gain on long sessions is large, and the fallback path is one you should already have. Start with one agent, measure time to first token before and after on your own longest sessions, and confirm that your replay path works by deliberately letting a thread expire in testing. Wait if you need zero data retention, HIPAA eligibility, Message Batches, token counting, on demand compaction, or Inference hooks, because the beta does not cover those cases yet. Wait also if your sessions are short, because the gain will be small and the extra code, while modest, still needs testing. For Claude Code users, the decision is already made for most of you: threads are on by default, so the practical step is to notice whether long sessions feel faster, and to report any odd behaviour to Anthropic rather than trying to toggle a setting that does not exist as a client flag. For readers tracking Anthropic more broadly, our Claude Duet waitlist guide covers the proactive agent that messages first, our Claude watermark guide covers output marking on newer models, and our automation tool chooser helps place Claude Code among other agent options. Sources: Anthropic message threads announcement and documentation, 2 November 2026, as reported by Unite.AI, Blockchain.News, EconoTimes, and The Next Web, 2 to 3 November 2026; Anthropic figures for 35 percent median time to first token on 500,000 to 1 million token requests, 800 KB to 1.8 KB median request size, 5 minute expiry, and beta header message-threads-2026-08-12, as reported in that coverage.
Frequently Asked Questions
What are Claude message threads?
They are a public beta feature on the Messages API that lets an agent send the full conversation once, then send only new messages plus the previous response ID on later turns, so the client stops resending the whole history every time.
How much faster do they make Claude Code?
Anthropic reports median time to first token falls by about 35 percent on requests with 500,000 to 1 million tokens, for most Claude Code users. Short sessions will see less benefit, and total response time is a different measure.
Do message threads lower my API bill?
No. Claude still reads the full conversation on every turn, so token usage, pricing, and rate limits are unchanged. The saving is in waiting time and upload size, not in tokens.
How do I turn threads on for my own agent?
Add the thread parameter to the first request and the beta header message-threads-2026-08-12, then send only new messages and the previous response ID on later requests. The official SDKs provide a helper for this flow.
What happens after 5 minutes of inactivity?
The thread expires, and your app must resend the full conversation to start a new thread. Keep your own copy of the history at all times, and treat a missing thread as a normal fallback, not a fatal error.
Who should not use the beta yet?
Apps that need zero data retention, HIPAA eligibility, Message Batches, token counting, on demand compaction, or Inference hooks, because the beta does not support those cases. Bedrock users should also wait for an official availability note.


