Still Resending Every Chat Turn to Claude? Message Threads Cut the Wait

Anthropic's new message threads beta lets Claude agents send only new messages each turn, cutting time to first token by about 35% on huge sessions. Here's how.

TheTechLane cover: 'Still resending every chat turn to Claude?' headline beside a stack of chat message cards where only the newest turn is highlighted, stitched by a thread to a spool topped with the TL logo

Anthropic has launched message threads in public beta for the Claude Messages API, letting agents send a conversation once and then only the new messages on each turn. On requests of 500,000 to 1 million tokens, the company says median time to first token fell by about 35% after it switched threads on for most Claude Code users.

Here's what you need to know:

  • Message threads went into public beta on November 2, 2026, behind the message-threads-2026-08-12 beta header.

  • You add one thread parameter: create on the first request, then continue with only new messages and the previous response id.

  • It saves time, not tokens: Claude still reads the full conversation, and pricing and rate limits don't change.

  • Threads expire 5 minutes after the last request, so your app must keep its own copy of the conversation and be ready to replay it.

  • Threads are not eligible for zero data retention (ZDR) or HIPAA setups.

UML sequence diagram of a Claude message thread: on turn 1 the agent sends the full conversation with system and tools and thread type create, the Messages API stores it under the response id and runs Claude; on turn 2 the agent sends only new messages with thread type continue and the previous message id, the API rebuilds the full conversation and Claude still reads all of it; the thread expires 5 minutes after the last request, so a later continue request gets a 404 thread_not_found error and the agent replays the full history in a new create request

How a Claude message thread works, turn by turn

What Happened

Anthropic announced the feature on Monday. According to the Claude Platform release notes for November 2, 2026, long conversations and agent loops "can now send smaller requests and get a lower time to first token with message threads," because "the API keeps the conversation on the server, so each later request sends only the new messages."

The problem it targets is simple. In Anthropic's announcement article, the company explains that "a coding agent might make hundreds of requests in one session, and each request resends every earlier message and tool result." Once a conversation reaches hundreds of thousands of tokens, resending all of it adds time before Claude starts responding.

The fix works in three steps, as laid out in Anthropic's message threads documentation:

  • Create. Send the first request as usual, with the full conversation, system and tools, plus "thread": {"type": "create"}.

  • Continue. Send only the messages since the last response, plus "thread": {"type": "continue", "previous_message_id": "..."}. Leave system and tools out; the thread keeps them.

  • Replay. If the thread is gone, a continue request returns a 404 thread_not_found error, and you send the full conversation again in a new create request.

Anthropic says it has already switched threads on by default for most Claude Code users, and that requests with 500k to 1M tokens saw median time to first token drop by about 35%. The Next Web's report on the launch also notes that the beta works on all Claude models, and that prices and rate limits stay the same.

Between turns, Anthropic holds each thread in memory, encrypted and not written to disk. The docs say the API deletes a thread no more than 1 hour after its last use.

Why It Matters

Agents are getting longer-lived. Coding agents, computer use agents and document-heavy workflows can run for hundreds of turns, and every turn has traditionally meant uploading, validating and tokenizing the entire history again. Threads move most of that work to just the new turn.

The catch is that this is a latency feature, not a cost feature. Anthropic is explicit that "Claude still reads the full conversation on every turn, so token usage stays the same," and Blockchain.News's summary of the beta repeats that standard Claude token rates and existing rate limits apply. If your bill is the problem, prompt caching is still the lever. Threads don't cache your prompt for you; you still choose where the cache breakpoints go.

It also moves a little state to Anthropic's side, which brings trade-offs. Threads are best-effort, short-lived and can't be listed, read or deleted through an API. And because they're not ZDR or HIPAA eligible, teams in regulated settings may not be able to use them at all. For more on how agents that run long and loose can go wrong, see our report OpenAI's GPT-6.1 Terra Halves Prices, but Will Your Agent Know When to Stop?

What It Means for Developers

If you run long Claude sessions, threads are worth testing, but the docs make clear you need to build for failure from day one.

  • Keep your own history. Your app stays the source of truth. No response tells you whether a turn was stored; you only find out on the next continue request.

  • Build the replay path first. Expired threads, fallback-model responses and requests from a different API key or workspace all return thread_not_found. The SDK thread helper replays the full conversation for you.

  • Don't change fixed fields mid-thread. model, tool_choice, thinking, mcp_servers and the beta headers must match the create request, or you get a 400 thread_fingerprint_mismatch error. Sending system or tools on a continue request also fails.

  • Continue from the latest id only. Threads are append-only, and each response id can be continued once. To branch or compact, start a new thread.

  • Watch the limits. Threads don't work with Message Batches, token counting or on-demand compaction, and a threaded request can carry at most 4 cache_control breakpoints.

  • Check your tool runner. The SDK's beta tool runner uses a thread by default; pass thread: false if you need the old behaviour.

Flowchart for handling a Claude message threads continue request: on 200 OK continue the next turn from the new response id; on 404 thread_not_found replay the full history in a new create request; on 400 thread_fingerprint_mismatch keep the fixed fields the same or start a new thread; on 400 thread_already_continued continue from the latest id or replay; on 400 thread_unsupported_request drop the unsupported feature or send the request without a thread

What to do when a continue request fails

What's Next

Message threads are in beta on every Claude model, across the Claude API, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) and Microsoft Foundry. Anthropic hasn't given a date for general availability.

The open questions: whether the 35% figure holds outside Claude Code's very large sessions, whether Anthropic will add a way to inspect or delete threads, and whether ZDR and HIPAA customers will eventually get access. Agents that hold more state on a provider's servers also raise the stakes for how that state is handled, a theme we explored in Can a Text File in Your Downloads Hijack Codex or Claude Code?

FAQ

Do message threads make Claude cheaper?

No. Anthropic says Claude still reads the full conversation on every turn, so token usage stays the same, and threads don't change pricing or rate limits.

What happens if a thread expires?

A thread expires 5 minutes after its last request. A continue request then returns a 404 thread_not_found error, and you send the full conversation again in a new create request. The SDK helper does this for you.

Can every team use message threads?

Not yet. Threads are a beta feature, they aren't eligible for zero data retention or HIPAA, and organizations with HIPAA readiness or Inference hooks turned on can't use them.

Sources

Follow TheTechLane

Keep learning AI, development, and modern developer technologies with TheTechLane.

Learn • Build • Share

Follow @thetechlanehq for more developer guides, tutorials, and practical technology content.