Anthropic Message Threads: 35% Faster Claude, Same Bill

Turn 200 of an agent loop on the Claude API used to look exactly like turn 1, only bigger. Every earlier message, every tool result, every screenshot, re-uploaded with each new request. On November 2, 2026, Anthropic put Message Threads into public beta on the Messages API, and that changes the shape of long sessions: the server now holds your conversation between turns, so your client sends only what is new. Anthropic reports a median 35% drop in time to first token on requests of 500,000 to 1 million tokens. This article explains what Message Threads is, how it works, why the 35% number is narrower than it sounds, and the fine print that matters before you wire it into production.

What Message Threads actually does

Since the Messages API launched, it has been stateless. Each turn resends the entire transcript: the full conversation, the system prompt, every tool definition, and in agent loops, hundreds of accumulated tool results. As Anthropic puts it in the announcement, a coding agent can make hundreds of requests in one session, and once a conversation reaches hundreds of thousands of tokens, resending all of it adds real time before Claude starts responding.

Message Threads splits the interaction into two kinds of requests. A create request sends the full conversation plus the new thread parameter, along with the system prompt and tools. The API stores the conversation and Claude's reply under the response ID. Every continue request after that sends only the messages since the previous response, together with that response's ID, leaving out the system prompt and tools. The API rebuilds the full conversation server-side before calling the model.

The payload difference is dramatic in the sessions this is built for. In long Claude Code conversations, median request size fell from about 800 KB to about 1.8 KB, according to developer coverage citing Anthropic's figures. That is the wire traffic shrinking, not the thinking. Message Threads is already on by default for most Claude Code users, which is why Anthropic can quote a median from a live rollout rather than a lab measurement. Direct API callers enable it with the message-threads-2026-08-12 beta header and the thread field; the official SDKs ship a thread helper that creates and continues threads, attaches the header, keeps the conversation in memory, and replays the full conversation automatically on specified continuation errors.

The 35% number, read carefully

The headline figure deserves a careful reading. Anthropic says that with threads on by default for most Claude Code users, requests with 500,000 to 1 million tokens see median time to first token fall by about 35%. Three qualifications sit inside that sentence.

First, it is Anthropic's own measurement from its own product rollout. No independent benchmark has reproduced it yet, and you should treat it as a vendor-reported median, not a guarantee on your workload.

Second, the gain lives in a specific band. Without a thread, every turn re-uploads the whole conversation, and the API validates and tokenizes all of it before the model reads a single new token. At 500,000 tokens, that bookkeeping dominates the wait; at 20,000 tokens, it is noise. The improvement scales with context size, so a short customer-support chat will notice nothing, while a marathon coding session will notice a lot.

Third, Anthropic's own list of beneficiaries tells you where the value concentrates: long-running coding agents where each tool result and file edit accumulates, computer-use agents where screenshots stay with the thread instead of being re-uploaded as base64 on every turn, and document and image-heavy workflows where requests are made smaller. If your sessions do not look like those, the 35% is not your number. For a sense of which agents actually run these long loops, see our roundup of the 7 best AI coding agents in 2026.

The bill does not move

Here is the most misread line of the week: this is a latency feature, not a cost feature. Claude still reads the full conversation on every turn, so input token usage is unchanged. Anthropic states plainly in the announcement that standard Claude token rates and existing rate limits apply. There is no new line item, no thread surcharge, and no discount. Anyone writing "35% faster" into a planning document as "35% cheaper" is making a mistake Anthropic explicitly warns against. Current rates live on Anthropic's official pricing page; threads do not change any of them.

Message Threads also does not replace prompt caching, and the two solve different halves of the same problem. A thread does not cache your prompt for you: you still place the cache breakpoints yourself, up to four per threaded request, and a breakpoint already sent can never be moved or removed, because a continue request cannot resend an earlier message. Prompt caching cuts the compute spent on the repeated prefix; threads cut the upload and validation of it. Anthropic's own docs do not enable automatic caching on threads, so teams serious about both will run them together.

The catches, stated plainly

The beta trades convenience for guarantees, and the docs are unusually direct about what you give up. Every one of these comes from Anthropic's own documentation, as summarized in the launch coverage:

Streaming has its own edge: clients must wait for the message_stop event before continuing from a response ID, because an earlier continue can return 404, and the SDK helper does not automatically retry a continue after a dropped stream. Turns written by fallback models are never stored, so the next turn resends everything regardless.

Two exclusions matter most for buyers. Message Threads is not eligible for zero data retention or HIPAA use, although Anthropic notes the feature does not affect eligibility for other zero-data-retention features. Regulated workloads are out. Our coverage of Anthropic's enterprise push explains why that boundary matters to compliance teams.

The bigger shift: the API goes stateful

The percentage is less interesting than the architecture. Anthropic's Messages API has been stateless since launch, and Message Threads makes it stateful by opt-in. It mirrors the pattern OpenAI's Responses API already established for server-side conversation state. The five-minute idle window is the tell: this first version is built for machine-speed loops, not humans. Any workflow with an approval gate will fall off the thread and pay the replay, because five minutes of waiting for a human decision expires the state.

If that window is still the only option at general availability, most production agents will use threads as the fast path and keep the full resend as the fallback. Anthropic's docs effectively tell you to build exactly that: keep your own copy of every message, build the replay path first, and treat automatic recovery as convenience rather than durability.

What to do in your code

If you ship an agent on the Messages API, the practical checklist is short:

1. Add the message-threads-2026-08-12 beta header and the thread parameter, or use the SDK thread helper. The full mechanics are in the official documentation.
2. Keep a canonical transcript client-side and build the replay path before you build anything else. Threads are the fast path; your own resend is the durable one.
3. Pair threads with prompt caching deliberately. Set your breakpoints at thread creation, up to four per request, and never plan to move one mid-thread.
4. Design for expiry. Approval gates, long tool calls, and idle pauses will 404; your code should treat a dead thread as routine, not an error.
5. Confirm your surface. The beta runs on the native Claude Platform, Claude Platform on AWS, Claude in Microsoft Foundry, and Claude Models on Google Cloud under Anthropic management, with beta support on every model.
6. Keep regulated traffic off threads. Zero-data-retention and HIPAA customers are excluded for now.

Message Threads is one of the least hyped and most useful API changes Anthropic has shipped this year. It fixes the exact tax that long agent sessions pay on every turn: the upload. It does not fix the bill, the context window, or the need to keep your own records. For teams whose agents live in half-million-token loops, that is a meaningful, honest upgrade. For everyone else, it is a preview of where the API is going.

Do Message Threads lower my Claude API bill?

No. Claude still reads the full conversation on every turn, so input token usage is unchanged, and Anthropic says standard token rates and existing rate limits apply. The feature cuts latency, specifically median time to first token on very long requests, and nothing else.

How do I enable Message Threads?

Add the message-threads-2026-08-12 beta header and the thread request parameter to Messages API calls, or use the official SDK thread helper, which handles creation, continuation, and one automatic full replay on continuation errors. Threads are already on by default for most Claude Code users; our Claude Code explainer covers that tool in detail.

What happens when a thread expires?

A thread expires five minutes after its last request, and thread contents are deleted no more than one hour after last use. Continuing against an expired thread returns a 404, at which point your client resends the full conversation as a new create request. This is why Anthropic requires you to keep your own copy of every message.

Do Message Threads replace prompt caching?

No. Threads do not cache your prompt; you still supply cache breakpoints or top-level cache control, up to four breakpoints per threaded request. Prompt caching reduces the compute spent on the repeated prefix, while threads reduce the upload and validation of it. They are complementary, not substitutes.

Which models and platforms support Message Threads?

The beta runs on the native Claude Platform, Claude Platform on AWS, Claude in Microsoft Foundry, and Claude Models on Google Cloud under Anthropic management, with beta support on every model. It is not available to organizations with Inference hooks enabled, and several features including Message Batches and token counting are unsupported.

Can regulated workloads use Message Threads?

Not in the beta. Threads are not eligible for zero data retention or HIPAA use. Anthropic notes this does not affect eligibility for other zero-data-retention features, but any workload with those requirements must stay on the standard stateless path for now.

Sources

• Anthropic, "Make long-running agents faster with message threads," claude.com, November 2, 2026 (official announcement): claude.com
• Anthropic, "Message threads," official documentation: platform.claude.com
• Anthropic, official API pricing (standard rates apply to threads): claude.com/pricing
• Unite.AI, "Anthropic Launches Message Threads Beta for Long-Running Agents," November 3, 2026: unite.ai
• SiliconNoon, "Claude Message Threads: 35% faster first token, same token bill," November 3, 2026: siliconnoon.com
• Gabriel Anhaia, "Claude's API Now Holds Your Agent's Conversation for 5 Minutes. Keep Your Own Copy," dev.to, November 2026: dev.to
• delimitter, "Anthropic cuts agent request payloads from 800 KB to 1.8 KB with Message Threads in public beta," dev.to, November 2026: dev.to
• AI Weekly, "Anthropic opens Message Threads beta, 35% faster first token," November 3, 2026: aiweekly.co
• lapaasvoice.com, "Claude Message Threads beta keeps active API conversations," November 3, 2026: lapaasvoice.com