Anthropic has opened Claude Message Threads in public beta, and it fixes one of the most annoying hidden costs of building AI agents: the wait. Until now, every turn of a long Claude API conversation forced the developer to resend the entire conversation history, tool results and all. On November 2, 2026, Anthropic launched a way to stop that resending, and the company reports that the change cuts the median wait for the first token by about 35% on very long requests. This guide explains what Claude Message Threads are, how they work, what they do not do, and whether you should switch them on.

Table of Contents
- What Are Claude Message Threads?
- The Problem Claude Message Threads Solve
- How Claude Message Threads Work, Step by Step
- What the 35% Faster Claim Really Means
- What Claude Message Threads Do Not Change
- Limits and Catches You Must Know Before You Build
- Who Benefits Most From Claude Message Threads
- How to Enable Claude Message Threads in Your Code
- Claude Message Threads vs Prompt Caching
- What Claude Message Threads Mean for US Developers
- Frequently Asked Questions
- The Verdict: Should You Use Claude Message Threads?
What Are Claude Message Threads?
Claude Message Threads are a new public-beta feature of the Claude Messages API that lets Anthropic’s servers hold an active conversation between turns. Instead of your application sending the full transcript with every request, you send the complete conversation once to open a thread. After that, each request carries only the new messages plus the ID of the previous response, and the API rebuilds the conversation on its side before calling the model.
The idea is simple, but the effect is large for a specific kind of workload. A coding agent can easily make hundreds of requests in a single session. A computer-use agent accumulates screenshots, tool outputs and long documents. In those sessions, the conversation can grow to hundreds of thousands of tokens, and resending all of it on every turn becomes the slowest part of the request. Threads remove that repeated upload from the critical path.
Anthropic says the feature is already switched on by default for most Claude Code users, which is why the company can quote a real-world median improvement rather than a laboratory measurement. For everyone else, Claude Message Threads are available now in public beta on the native Claude Platform, on the Claude Platform on Amazon Web Services, in Claude on Microsoft Foundry, and on Anthropic-managed Claude models on Google Cloud.
It is worth being precise about what this is. Threads are not a new model, not a new pricing tier, and not a memory product. They are a transport and session optimisation for the existing Messages API. The model still sees the same conversation. The difference is only in how much data your application has to push across the network on each turn.
The Problem Claude Message Threads Solve
Since the Messages API launched, it has been stateless. That is a deliberate design choice with real advantages: every request is self-contained, easy to reason about, easy to retry, and easy to move between providers. But statelessness has a price, and that price grows with every turn.
Imagine an agent session that has reached 500,000 tokens. Without Claude Message Threads, turn number 200 sends all 500,000 tokens again, including every earlier message, every tool result and every image. The API must receive, validate and tokenise all of that material before the model can read a single new token. The user waits through all of that bookkeeping before seeing any response at all.
Anthropic’s own example makes the scale vivid. In long conversations, the company says the median request shrank from about 800 kilobytes to about 1.8 kilobytes once threads were in use. That is not a small optimisation. It is the difference between uploading a document and sending a text message. When the request itself is hundreds of times smaller, the time spent before generation starts falls sharply.

This matters most for agentic workloads, which are exactly the workloads everyone is building right now. A chatbot that answers one question and forgets it will never notice the difference. An agent that works through a codebase for an hour, calling tools, reading files and updating its plan, will feel it on every single turn. The longer the session runs, the worse the resending problem gets, and the more threads help.
There is a second, quieter benefit. Smaller requests are easier on your own infrastructure too. Less data leaves your servers, fewer bytes cross the network, and retries after a failure cost less. None of that shows up in a benchmark headline, but it shows up in reliability and in the responsiveness your users actually experience.
How Claude Message Threads Work, Step by Step
The flow of Claude Message Threads has four stages, and understanding each one matters because the feature’s limits all come from how the thread is stored.
Step 1: Open the thread with a full first request
The first request looks like a normal Messages API request. You send the system prompt, the tools, the full conversation so far, and you add the thread parameter plus the message-threads beta header. That request creates the thread on Anthropic’s side. The official software development kits handle the header and the helper function for you, so most developers will not hand-roll the raw HTTP.
Step 2: Continue with only what is new
Every later request sends only the messages added since the previous turn, together with the ID of the previous response. The API takes those new messages, joins them to the stored conversation, and calls the model. Your application no longer uploads the history, the old tool results or the old screenshots.
Step 3: The thread lives in memory, not on disk
Anthropic says threads are held in memory, encrypted, and never written to durable storage. That design choice is what makes threads fast, and it is also what makes them fragile. A thread is kept on a best-effort basis. It expires five minutes after its last request, and Anthropic deletes it no more than one hour after its last use.
Step 4: Handle expiry by resending everything
If you continue against a thread that has expired, the API returns a 404 error. Your application must then resend the full conversation from its own copy to start a new thread. This is the single most important implementation rule: your application must always keep its own complete copy of the conversation. Threads are an optimisation, not a storage service. Never treat the thread as the only copy of anything.

What the 35% Faster Claim Really Means
The headline number attached to Claude Message Threads is a median reduction of about 35% in time to first token, often abbreviated as TTFT, for requests containing between 500,000 and one million tokens. TTFT measures how long a user waits before the model starts generating its response. It is the pause before the first word appears, and in interactive agent products it is the delay users notice most.
Three qualifications keep that number honest. First, it is a median, not a guarantee. Half of comparable requests improved by more than 35%, and half by less. Your own improvement will depend on your session length, your network, and how much of the wait was upload bookkeeping rather than model thinking.
Second, the number applies to very long requests. At 500,000 tokens, the bookkeeping of receiving and tokenising the whole conversation dominates the wait, so removing it moves the total dramatically. At 20,000 tokens, the same bookkeeping is a rounding error, and threads will barely register. If your sessions are short, this feature is not for you, and that is fine.
Third, the improvement is in latency, not in total generation time. Once the model starts producing tokens, it generates at its normal speed. Threads shorten the silence before the answer begins. They do not make the answer itself arrive faster, and they do not make the model smarter.
None of that makes the feature less useful. For long-running agents, the pause before each response repeats hundreds of times per session. Cutting a third off that pause, turn after turn, changes how responsive the whole product feels. It is the kind of improvement that users describe as the product feeling “snappier” without being able to say why.
What Claude Message Threads Do Not Change
The most misunderstood fact about Claude Message Threads is also the most important one: they do not reduce your token bill. Claude still reads the full conversation on every turn, so the number of input tokens processed by the model is unchanged. Anthropic has confirmed that standard token pricing and existing API rate limits continue to apply exactly as before.
This distinction will matter in planning meetings. It is easy to hear “35% faster” and write down “35% cheaper” in a budget document. That would be wrong. If your costs are dominated by input tokens on long sessions, threads will not lower them. What they lower is waiting time and request size, not consumption.
Prompt caching is also unaffected, and it still needs to be requested explicitly. Threads and prompt caching solve different problems: threads remove the repeated upload, while caching reduces the cost of reprocessing repeated prefixes. They can work together, but one does not replace the other, and enabling threads does not automatically enable caching.
Finally, the model itself is unchanged. Threads do not alter what the model knows, how it reasons, or how it uses tools. A session that produced a bad answer before threads will produce the same bad answer after them, only sooner. Quality work still depends on your prompts, your tools and your agent design.
Limits and Catches You Must Know Before You Build
Claude Message Threads are a public beta, and the beta status shows in a list of restrictions that could easily break a careless integration. Read this section before you write code, not after.
Threads expire quickly and silently
A thread expires five minutes after its last request. There is no warning, no heartbeat and no API to check whether a thread is still alive. You discover a thread is gone only when the next request returns a 404, and then you must resend the full conversation. Design your retry path first, and test it by deliberately letting a thread expire.
Each response ID can be continued exactly once
Threads are append-only, and each response ID can be continued exactly once. Branching a conversation, retrying a turn from the same response ID, or replaying a request can all collide with this rule. If your agent design branches or retries aggressively, you need to think carefully about how thread continuation fits that pattern.
System prompts and tools are create-only
The system prompt and the tool definitions are set when the thread is created. Resending them on a later turn returns a 400 error. The same applies to several other settings: the model, the thinking configuration, the tool choice, the MCP servers, the context management settings and the top-level cache settings are fingerprinted at creation, and any drift between turns returns a fingerprint-mismatch error. In practice, this means a thread represents one fixed configuration. If you need to change the configuration, start a new thread.
No thread management API exists
There is no API to list, read or delete a thread. You cannot inspect what the server stored, you cannot clean up a thread you no longer need, and no response tells you whether the API stored a given turn. Your own conversation log is the only reliable record. Treat the server-side thread as a cache that may vanish, never as a database.
Several features are unsupported
Message Batches, token counting, on-demand compaction, most context editing features and inference hooks are unsupported with threads. If your product depends on any of those, threads may not be compatible with your current design, and you should check the current documentation before committing.
Regulated workloads are excluded
Claude Message Threads are not eligible for zero data retention configurations, and they do not work for HIPAA organisations. If your workload requires those guarantees, this feature is simply not available to you, and no workaround changes that. That exclusion alone will keep some healthcare, finance and enterprise teams on the classic stateless pattern for now.

Who Benefits Most From Claude Message Threads
Anthropic names three workload types, and each one maps neatly onto the products US developers are actually shipping in late 2026.
Long-running coding agents are the clearest winners. A coding agent working through a real repository accumulates file contents, diffs, test outputs and tool results over hours. Sessions routinely pass hundreds of thousands of tokens, and the agent makes hundreds of requests. This is the workload Claude Code itself represents, and it is no accident that the feature arrived there first.
Computer-use agents come next. An agent driving a browser or a desktop accumulates screenshots on every step, and screenshots are heavy. Resending dozens of screenshots on every turn is exactly the kind of waste threads eliminate. The request-size reduction matters even more here than the latency figure suggests.
Document- and image-heavy workflows complete the trio. Legal review, research synthesis, medical document processing and insurance claim handling all involve long source documents that must stay in context for the whole session. When the document is the context, resending it every turn is pure overhead, and threads remove it.
Who does not benefit? Short chatbot sessions, single-shot classification calls, and anything where the conversation stays under a few tens of thousands of tokens. For those workloads, the classic stateless request is already fast, and adding thread management buys complexity without a payoff. The honest test is simple: if your median session is short, skip this feature and spend the engineering time elsewhere.
How to Enable Claude Message Threads in Your Code
Enabling Claude Message Threads takes three changes to a standard Messages API integration. First, add the thread parameter to your requests and the message-threads beta header, using the beta identifier message-threads-2026-08-12. The official SDKs provide a helper function for this, so check your SDK version before hand-rolling headers.
Second, restructure your request loop so the first request sends the full conversation and every later request sends only the new messages plus the previous response ID. Keep the full conversation in your own store on every turn, because you will need it the moment a thread expires.
Third, build the failure paths before you ship. Handle the 404 that means “thread expired, resend everything”. Handle the 400 that means “you resent a create-only field”. Handle the fingerprint-mismatch error that means “your configuration drifted”. Then test each path deliberately: let a thread sit idle for more than five minutes, change a setting mid-thread, and retry a turn. A beta feature rewards the teams that test its failure modes, not the teams that only test its happy path.
Rollout advice follows the same shape as any beta adoption. Start with one internal agent or one low-risk workload. Measure your own TTFT before and after, on your own session lengths, rather than trusting the headline 35%. Compare the median and the tail, not just the average, because agent products live or die on their slowest turns. Only then extend threads to customer-facing workloads.

Claude Message Threads vs Prompt Caching
Developers often confuse Claude Message Threads with prompt caching, because both involve long conversations and both mention efficiency. They are different tools, and the table below keeps them straight.
| Question | Claude Message Threads | Prompt Caching |
|---|---|---|
| What does it reduce? | Request size and time to first token | Cost and latency of reprocessing repeated prefixes |
| Does it cut your token bill? | No, input tokens are unchanged | Yes, cached tokens are billed at a lower rate |
| What do you send each turn? | Only new messages plus the previous response ID | The full conversation, with cache breakpoints marked |
| Is it automatic? | No, you opt in with the thread parameter | No, you request it explicitly |
| Main risk | Thread expiry and the 404 fallback | Cache misses on changed prefixes |
The practical conclusion is that the two features complement each other. Prompt caching attacks the cost of reprocessing, while threads attack the cost of retransmitting. A long-running agent that enables both gets smaller requests and cheaper reprocessing. An agent that enables only threads gets faster first tokens at the same bill. Knowing which problem you actually have is what decides which feature to adopt first.
There is also a useful contrast with the older pattern of summarising or compacting conversations. Compaction genuinely reduces tokens by discarding or compressing history, but it risks losing detail. Threads lose nothing: the model still reads everything. That makes threads the safer first step for teams that are nervous about compaction changing answer quality.
What Claude Message Threads Mean for US Developers
For US developers, the timing of Claude Message Threads is convenient. Agent products are moving from demos to daily tools, and the users of those tools judge them on responsiveness. A coding assistant that pauses noticeably before every action feels broken, even if its answers are excellent. Cutting a third off that pause on long sessions is a genuine product improvement, not a benchmark curiosity.
There is also a competitive angle. Agent frameworks and coding tools now compete heavily on the feel of long sessions. The teams that adopt thread-style session handling early will ship agents that feel faster in exactly the long, complex tasks where users are most impatient. The teams that ignore it will keep paying the resend tax on every turn while their competitors do not.
Budget planning needs the honest version of the story, though. Threads do not change the price of tokens, so finance teams should not expect a lower API bill. What changes is the user experience per dollar already spent, plus a small reduction in your own network and retry costs. Pitch it internally as a latency and reliability win, and you will set expectations that the feature can actually meet.
For small teams and solo developers, the appeal is different. You get a simpler mental model for long sessions: open a thread, stream new messages into it, keep your own copy as backup. You do not need to build your own session server or manage your own conversation cache. Anthropic holds the thread, you hold the truth, and the five-minute expiry keeps you honest about which is which.
One more audience deserves a mention: builders of multi-agent systems. When one lead agent coordinates many subagents, each subagent session is itself a long conversation, and the resend tax multiplies across all of them. Thread-style handling at the API level removes that tax without requiring the framework to reinvent session storage. Expect agent frameworks to adopt this pattern quickly, and expect it to become a default rather than an option within a year.
Frequently Asked Questions
Are Claude Message Threads available to everyone?
Claude Message Threads are in public beta as of November 2, 2026, on the native Claude Platform, on AWS, in Microsoft Foundry and on Anthropic-managed Claude models on Google Cloud. They are switched on by default for most Claude Code users. API developers opt in with the thread parameter and the beta header.
Do Claude Message Threads reduce API costs?
No. Claude still reads the full conversation on every turn, so input tokens, standard pricing and rate limits are unchanged. Threads reduce latency and request size, not the token bill. Prompt caching is the separate feature that reduces the cost of repeated prefixes.
What happens when a Claude Message Threads session expires?
A thread expires five minutes after its last request. The next request against it returns a 404, and your application must resend the full conversation from its own copy to start a new thread. Always keep your own complete copy of the conversation.
Can I use Claude Message Threads for healthcare or zero-retention workloads?
No. Threads are not eligible for zero data retention configurations and do not work for HIPAA organisations. Those workloads should stay on the classic stateless Messages API pattern.
Do Claude Message Threads work with Message Batches?
No. Message Batches, token counting, on-demand compaction, most context editing and inference hooks are unsupported with threads in the current beta. Check the current documentation before combining threads with those features.
How much faster are Claude Message Threads really?
Anthropic reports a median time-to-first-token reduction of about 35% for requests between 500,000 and one million tokens, measured with threads enabled by default for most Claude Code users. Short sessions will see little or no improvement, because the resending overhead is small at that scale.
The Verdict: Should You Use Claude Message Threads?
Claude Message Threads are a narrow feature that solves a real problem extremely well. If you build long-running agents, especially coding agents, computer-use agents or document-heavy workflows, they are worth adopting now, in beta, with the failure paths tested. The 35% median improvement on very long requests is meaningful, the request-size reduction from roughly 800 kilobytes to 1.8 kilobytes is dramatic, and the integration cost is small.
If your sessions are short, skip them. If your workload needs zero data retention or HIPAA guarantees, you cannot use them yet. If your product depends on Message Batches or compaction, check compatibility first. And whatever you build, never mistake a thread for storage: keep your own copy of every conversation, handle the 404, and treat expiry as a normal event rather than an error.
The bigger story is what threads signal about where agent APIs are heading. Stateless requests were the right default for chatbots. Agents are not chatbots. They run for hours, accumulate enormous context, and need the API to meet them halfway. Threads are Anthropic’s first step toward an API designed for sessions rather than single turns, and the developers who learn its rules now will be ready for whatever comes next.
For more on how Claude is changing, read our guides to the Claude text watermark rolling out to older Claude models, the GDPx benchmark where the best AI scores just 12%, and LongCat 2.5, the 1.6-trillion-parameter agent model. For the primary reporting behind this article, see the detailed breakdowns from SiliconNoon and Gadgets 360.
