Anthropic has introduced Message Threads in public beta for the Claude API, giving developers a way to make long-running AI agents respond faster without resending the entire conversation history with every request. The company says the feature has reduced median time to first token by approximately 35% for very long Claude Code requests containing 500,000 to one million tokens.
The feature works by keeping an active conversation on Anthropic’s servers. Developers send the complete conversation when creating a thread, then submit only new messages and the previous response ID on subsequent turns. This makes individual API requests much smaller and reduces the time spent uploading and processing repeated conversation history. However, it does not reduce the number of tokens Claude reads or change standard API pricing and rate limits.
Key Takeaways
- Anthropic has launched Message Threads in public beta for its Claude Messages API.
- Developers no longer need to resend the complete conversation history on every API request.
- Anthropic reports approximately 35% lower median time to first token for requests containing 500,000 to one million tokens.
- Message Threads is already enabled for most Claude Code users, according to Anthropic.
- The feature is useful for coding agents, computer-use agents and document-heavy workflows.
- Threads expire five minutes after the last request and are deleted no more than one hour after their last use.
- Token pricing and existing rate limits remain unchanged.
- Message Threads is not eligible for zero data retention or HIPAA configurations.
What Are Anthropic’s Message Threads?
AI agents often need to maintain long conversations while completing complicated tasks.
For example, a coding agent may inspect a software project, read several files, modify code, run tests and fix errors. Every action adds information to the conversation.
Under the traditional Messages API workflow, developers generally have to send the accumulated conversation history again with every new request.
As an agent continues working, that history can become extremely large. A session involving hundreds of thousands of tokens can require repeatedly uploading substantial amounts of previously submitted information.
Anthropic’s Message Threads feature addresses this problem by allowing the API to maintain the conversation between requests.
Instead of repeatedly sending everything, developers send the complete conversation once and then provide only the latest messages and a reference to the previous response.
This reduces the size of subsequent requests and helps Claude begin responding sooner.
How Message Threads Work
Anthropic has designed the feature around three main steps.
1. Create a Thread
The first request works similarly to a conventional Claude API request.
Developers send the complete conversation, including the system prompt, available tools and messages. They also include a parameter that tells the API to create a new thread.
Anthropic stores the conversation under the response ID.
2. Continue the Conversation
For subsequent requests, developers send only the new messages and the ID of the previous response.
The API uses the stored conversation to reconstruct the full context before calling Claude.
This means developers no longer need to upload the entire conversation history repeatedly.
3. Replay When a Thread Expires
Message Threads are temporary.
A thread expires five minutes after its last request. If the application attempts to continue an expired thread, it must create a new thread by resending the full conversation.
Anthropic’s SDK helper can automatically handle certain thread-expiration and continuation errors by replaying the conversation.
Developers must still maintain their own copy of the conversation because the API does not provide a facility to list, read or delete stored threads.
Anthropic Reports 35% Lower Latency
The biggest headline figure is the improvement in time to first token, commonly abbreviated as TTFT.
TTFT measures how long a user waits before an AI model starts generating its response.
Anthropic says Message Threads have reduced median TTFT by approximately 35% for requests containing between 500,000 and one million tokens.
This is particularly relevant for long-running AI agents, where the same conversation may contain hundreds of tool calls and large amounts of accumulated context.
The improvement does not mean every Claude API request becomes 35% faster. The reported result applies to particularly long requests, where repeatedly transmitting conversation history creates a significant overhead.
The feature can also make request sizes much smaller because subsequent calls contain only the latest messages rather than the entire conversation.
Why This Matters for AI Coding Agents
Coding agents are among the most obvious beneficiaries of Message Threads.
A typical coding agent may need to:
- Read project files and understand their structure.
- Identify bugs and suggest changes.
- Modify multiple files.
- Execute terminal commands.
- Run tests and inspect errors.
- Repeat the process until the task is complete.
Each operation can add tool results and other information to the conversation.
Without Message Threads, the application repeatedly sends the accumulated history to Claude. With threads, it can send only the new information.
This is also useful for computer-use agents, which may work with screenshots and repeated interactions, as well as document-heavy workflows involving large files and images.
For developers building autonomous agents, reducing the time spent waiting for each model response can improve the overall experience, particularly when a task requires many consecutive API calls.
Message Threads Do Not Reduce API Token Costs
There is an important distinction between reducing request size and reducing token consumption.
Message Threads make subsequent API requests smaller, but Claude still reads the complete conversation on every turn.
Consequently, the feature does not automatically reduce the number of input tokens processed by the model.
Anthropic has confirmed that standard token pricing and existing rate limits remain unchanged.
Developers should therefore view Message Threads primarily as a latency and request-efficiency improvement, rather than a direct API cost-saving feature.
Prompt caching remains a separate mechanism that developers can configure to reduce repeated processing costs where eligible.
Availability Across Cloud Platforms
Anthropic has made Message Threads available in public beta across several Claude deployment environments.
| Platform | Availability |
|---|---|
| Claude API | Public beta |
| Claude Platform on AWS | Public beta |
| Claude Models on Google Cloud (Anthropic managed) | Public beta |
| Claude in Microsoft Foundry | Public beta |
The feature is available across Claude models in beta.
Developers must include the beta header message-threads-2026-08-12 when using the API directly. Anthropic’s SDK thread helper handles the required header automatically.
Existing API pricing and rate limits continue to apply.
Important Data Retention and Security Limitations
Message Threads introduce a server-side conversation storage mechanism, so developers need to understand how the information is handled.
Anthropic says thread contents are held in memory, encrypted using a server-managed key and never written to durable storage. Threads are deleted no more than one hour after their last use.
However, the feature is not eligible for zero data retention (ZDR) configurations or HIPAA configurations.
This matters for organisations handling sensitive customer information, healthcare data or other regulated content.
Developers must also maintain their own conversation records because Anthropic does not offer an API to retrieve or manage stored threads.
The temporary server-side storage makes the feature convenient for active sessions, but it may not be suitable for every application or compliance requirement.
The Bigger Picture
Anthropic’s Message Threads launch highlights an increasingly important challenge in AI development: making agents efficient during long-running tasks.
As AI systems move beyond simple question-and-answer interactions, they increasingly need to maintain context across hundreds of actions, tool calls and decisions. Repeatedly transmitting large conversation histories can become a bottleneck.
Message Threads address part of that problem by separating conversation storage from the individual API requests.
The development also shows that improving AI performance is not always about building larger models. Improvements to API infrastructure, context management and request handling can make existing models more responsive.
Looking Ahead
The next challenge for Anthropic will be making long-running agent workflows faster while improving how developers manage context, storage and costs. Message Threads provide a useful foundation, but developers will still need to handle thread expiration, maintain their own conversation history and evaluate the feature against their security requirements.
For companies building coding assistants, computer-use agents and automated research tools, the public beta offers an opportunity to experiment with smaller API requests and lower response latency. If the reported improvements translate into real-world deployments, conversation management could become an increasingly important part of the next generation of AI agent infrastructure.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
