Claude Message Threads: Faster Long-Running AI Agents

Anthropic launched Claude message threads in public beta on Monday, November 2. The idea is simple. Your agent sends the full conversation once. After that, it sends only the new messages.

So why does this matter? Long agent sessions get slow, because every turn uploads the whole history again. In this post, I will explain how the feature works, what it changes and what it does not. Then I will share how I would test it.

What Are Claude Message Threads?

First, the problem. A coding agent can make hundreds of requests in one session. Each request normally carries every earlier message and tool result. Once that history reaches hundreds of thousands of tokens, resending it adds a delay before Claude starts to reply.

Claude message threads fix that transport step. According to Anthropic’s announcement, the API keeps the conversation on the server for a short time. Then each later request carries only what is new, plus the ID of the previous response.

In other words, the request gets smaller. The model, however, still sees the full conversation on every turn.

How the Create and Continue Flow Works

The official docs describe three steps. Here is the short version:

• Create: send the first request as usual, with the full conversation, system and tools. Then add "thread": {"type": "create"}.
• Continue: send only the new messages. Also add "type": "continue" and the previous_message_id of the last response.
• Replay: if a thread can’t continue, the API returns a 404 error. In that case, you send the full conversation again in a new create request.

Every request that uses Claude message threads also needs the message-threads-2026-08-12 beta header. On top of that, you leave system and tools out of continue requests. If you send either one, even as null, the API returns a 400 error.

Some fields must stay fixed for the whole thread. For example, model, tool_choice and thinking must keep the same values. Otherwise, you get a thread_fingerprint_mismatch error.

Claude Message Threads Cut Wait Time by About 35%

Now for the main benefit. Anthropic has already turned threads on by default for most Claude Code users. On requests with 500k to 1M tokens, it says median time to first token dropped by about 35%.

That number matters for agents. A faster first token means each step of a loop starts sooner. Over hundreds of steps, those savings add up.

Anthropic also lists the best use cases:

• Long-running coding agents, where each tool result or file edit grows the conversation
• Computer use agents, where screenshots stay with the thread instead of being uploaded again
• Document and image-heavy workflows

The rule is easy to remember. The more context your agent carries, the more threads can help.

What Claude Message Threads Do Not Change

Here is the catch, though. Threads save time, not money. Claude still reads the whole conversation on each turn, so token usage stays the same. Likewise, Anthropic says pricing and rate limits are unchanged.

As The Next Web points out, Anthropic’s cost lever is caching instead. However, a thread does not cache your prompt for you. You still choose the cache breakpoints yourself.

For example, you can send a top-level cache_control on every request of the thread. Still, keep the limit in mind: a thread request can carry at most four breakpoints.

Limits, Privacy and Where It Runs

Claude message threads are short-lived by design. A thread expires five minutes after its last request. Also, the API deletes it no more than one hour after its last use.

For that reason, your app must stay the source of truth. Keep your own copy of every message. Then build the replay path from day one. Notably, there is no API to list, read or delete a thread.

On privacy, the API holds each thread in memory. It is encrypted under a server-managed key and never written to durable storage. Even so, message threads are not eligible for zero data retention. In addition, organizations with HIPAA readiness enabled can’t use them.

A few features don’t work with threads yet. These include Message Batches, token counting and compaction on demand.

Availability is broad, by contrast. The beta works on every Claude model. It runs on the Claude API, Claude Platform on AWS, Claude Models on Google Cloud and Microsoft Foundry.

How I Would Test Claude Message Threads

So should you switch on day one? Here is how I would approach it, step by step.

• First, start with the SDK thread helper. It adds the beta header and handles the 404 replay for you.
• Second, pick your longest agent loop. Short chats won’t show much gain.
• Next, measure time to first token before and after. Use the same tasks for both runs.
• Then, check your compliance needs. If you rely on zero data retention, threads are not for you yet.
• Finally, keep your own full message history in every case.

The SDK’s beta tool runner also uses a thread by default. So if you already use it, you may get the speedup with little work.

This fits a wider trend, too. Agents now run longer and carry more context. For instance, I covered how Google pitched its Gemini 4 Carbon model for long, multi-step coding work.

Overall, Claude message threads are a small API change with a clear payoff. They won’t cut your bill. However, they can make long agents feel faster, and that matters when every step waits on the last one.