claudekit / updates / message-threads
[ NEW · ]

Make long-running agents faster with message threads (public beta)

Message threads, now in public beta on the Claude Platform, let you send your conversation once so the API receives only what's new with every turn. This reduces time to first token (TTFT) in long sessions, while token usage stays the same.

Official announcement →

This article is a summary based on official documentation.

Overview

Message threads are now in public beta on the Claude Platform. New in the Messages API, they let you send your conversation once, and the API receives only what’s new with every turn. That keeps time to first token (TTFT) lower and steadier as the conversation grows.

A coding agent might make hundreds of requests in one session, and once a conversation reaches hundreds of thousands of tokens, resending all of it adds time before Claude starts responding. Message threads are on by default for most Claude Code users, where requests with 500k to 1M tokens see median TTFT drop by about 35%.

Key features

  • Send only what’s new

    Without a thread, every turn uploads the whole conversation again, and the API validates and tokenizes all of it again. With a thread, most of that work covers only the new turn. Your first request sends the full conversation with system and tools and adds the thread parameter. Later requests send only the new messages and the id of the previous response.

    // First request
    "thread": {"type": "create"}
    
    // Later requests (leave out system and tools)
    "thread": {"type": "continue", "previous_message_id": "<previous id>"}
  • SDK thread helper

    The SDK has a thread helper that builds the thread requests for you. It creates a thread on the first turn, continues it after that, and adds the beta header. When a continue request returns thread_not_found or a similar error, it replays the full conversation once in a new create request. In Python, you create it with client.beta.messages.thread(...) and send turns with thread.send(...).

  • Built for active sessions

    Message threads are best for active sessions where latency matters, including long-running coding agents, where each tool result or file edit adds to the conversation, computer use agents, where screenshots stay with the thread instead of being re-uploaded on every turn, and document- and image-heavy workflows.

  • Available on four platforms

    The public beta covers the native Claude Platform, Claude Platform on AWS, Claude in Microsoft Foundry, and Claude Models on Google Cloud (Anthropic managed). If you build requests yourself, send the message-threads-2026-08-12 beta header on every request of a thread.

Notes

  • Token usage doesn’t change — Claude still reads the full conversation on every turn, so token usage stays the same. Standard Claude token rates and existing rate limits apply.
  • Prompt caching is still your call — A thread does not cache your prompt for you. To cache each turn, send a top-level cache_control on every request of the thread. A request with thread can carry at most 4 cache_control breakpoints.
  • Threads are short-lived — A thread expires 5 minutes after its last request, and the API deletes it no more than 1 hour after its last use. If it can no longer be continued, a continue request returns a 404 error and you send the full conversation again. Your application stays the source of truth, so the docs recommend keeping your own copy of every message and building the replay path from the start.
  • Some fields are fixed for the whole thread — Values such as model, thinking, tool_choice, and the top-level cache_control must match on every request. A thread is append-only, so to edit or branch an earlier message, start a new thread.
  • Unsupported features — Threads don’t support Message Batches, token counting, compaction, or context editing (with one clear_thinking_20251015 exception). Organizations with HIPAA readiness enabled or Inference hooks turned on can’t use them either.
  • Not ZDR eligible — A thread is held in memory, encrypted under a server-managed key, and never written to durable storage, but message threads are not eligible for Zero Data Retention (ZDR). Using this feature does not affect your use of other ZDR eligible features.
  • Not the same as session threads — Message threads are different from session threads in Claude Managed Agents.
  • Learn more — See the message threads docs for per-request field rules, error codes, and supported models.
§ 4

Frequently Asked Questions

frequently asked
§ 4.1
What are message threads?
New in the Messages API, message threads let you send your conversation once, and the API receives only what's new with every turn. You add the thread parameter to a request, and later requests include only the new messages and the id of the previous response.
§ 4.2
Do message threads reduce token costs?
No. Claude still reads the full conversation on every turn, so token usage stays the same. Standard Claude token rates and existing rate limits apply. What improves is time to first token (TTFT).
§ 4.3
Where are message threads available?
As of the November 2, 2026 announcement, message threads are in public beta on the native Claude Platform, Claude Platform on AWS, Claude in Microsoft Foundry, and Claude Models on Google Cloud (Anthropic managed). Every request of a thread needs the message-threads-2026-08-12 beta header, which the SDK thread helper adds for you.
§ 4.4
Do Claude Code users need to turn this on?
Per the announcement, message threads are on by default for most Claude Code users. Requests with 500k to 1M tokens see median TTFT drop by about 35%.
§ 4.5
What happens when a thread expires?
A thread expires 5 minutes after its last request, and a continue request then returns a 404 error. Send the full conversation again in a new create request. The SDK thread helper does this replay once for you.
§ 4.6
Are message threads eligible for Zero Data Retention (ZDR)?
No. The docs state that message threads are not ZDR eligible. A thread is held in memory, encrypted under a server-managed key, never written to durable storage, and deleted no more than 1 hour after its last use.