Takeaway: Anthropic’s Messages API now has message threads in public beta (noted in the Claude Platform release notes for Nov 2, 2026). Agents send the full conversation once with thread: {type: "create"}, then only new messages plus the previous response id with thread: {type: "continue", previous_message_id}. Anthropic reports median time to first token (TTFT) about 35% lower on 500k–1M token Claude Code sessions, with threads on by default for most Claude Code users. Smaller requests cut latency — not token cost. Claude still reads the full conversation; pricing and rate limits are unchanged. This is an API/runtime story for long agent loops, distinct from this morning’s ChatGPT Chat/Work tabs merge and from Claude Managed Agents session threads.
Primary sources: Anthropic’s message threads product article and Messages API message-threads docs; optional press corroboration from The Next Web.
Why long agent loops were paying a resend tax
A coding or computer-use agent can make hundreds of Messages API turns in one session. Without threads, every turn re-uploads every earlier user message, assistant reply, tool result, screenshot, and file blob. Once the history sits at hundreds of thousands of tokens, the client spends real time shipping and the API spends real time validating and tokenizing that payload before Claude starts answering.
Message threads keep a short-lived server-side conversation so most of that work covers only the new turn. Your app still owns the durable transcript: Anthropic’s docs are explicit that the application is the source of truth and must be ready to replay on a 404.
How create, continue, and replay work
Send the beta header anthropic-beta: message-threads-2026-08-12 on every request in the thread. The SDK thread helper adds it for you.
- Create. Call Messages as usual with the full conversation,
system, andtools, and add"thread": {"type": "create"}. The API stores the conversation (including Claude’s reply) under the responseid. - Continue. Send only messages since the previous response, with
"thread": {"type": "continue", "previous_message_id": "<prior response id>"}. Leavesystemandtoolsout — the thread keeps the create-request values. Keep fixed fields such asmodelidentical or you getthread_fingerprint_mismatch. - Replay. Threads are best-effort. A thread expires 5 minutes after its last request and is deleted ≤1 hour after last use. If continue returns 404 (
thread_not_found), resend the full conversation in a new create and continue from that new response id. The SDK helper does this replay for you.
There is no list/read/delete API for threads. Each response id can be continued once; always continue from the latest id. To edit or branch earlier turns, start a new create. Compaction-on-demand is not available with threads — summarize in your code and create a new thread from the summary.
What the ~35% TTFT claim means (and what it does not)
Anthropic’s article states that with message threads on by default for most Claude Code users, requests with 500k to 1M tokens see median TTFT drop by about 35%. That is a latency win from smaller uploads and less re-validation/tokenization of the prior history.
It is not a cost cut. Claude still reads the full conversation on every turn. Token usage, standard Claude token rates, and existing rate limits stay the same. Do not budget “35% cheaper agents” — budget “snappier first token on huge sessions.” Prompt caching still needs explicit cache_control; a thread does not cache the prompt for you.
Best use cases
- Long-running coding agents — each tool result or file edit grows the conversation; Claude Code is already leaning on threads by default for most users.
- Computer-use agents — screenshots can stay with the thread instead of being re-uploaded every turn (see also our note on Vercel Labs agent-desktop accessibility computer use).
- Document- and image-heavy workflows — large multimodal payloads benefit most when only the delta ships after create.
- Active sessions where latency matters — threads help most when turns keep coming inside the 5-minute idle window.
For adjacent agent product patterns outside Anthropic, see GitHub Copilot connected cloud sessions and MCP connectors and DeepSeek’s open-source coding agent prototype. OpenAI’s product UX merge of Chat and Work is a different layer — UI consolidation, not Messages API request shaping — covered in our morning ChatGPT Chat/Work merge post. Capacity stories such as ChatGPT + Codex shared December usage limits are likewise separate from Anthropic’s thread latency feature.
Message threads vs full-resend Messages API
| Dimension | Full-resend Messages API | Message threads (beta) |
|---|---|---|
| What you send after turn 1 | Entire conversation every turn | Only new messages + previous_message_id |
| system / tools on later turns | Typically re-sent | Create-only; sending them on continue → 400 |
| TTFT on huge sessions | Grows with history upload/validate work | Anthropic: ~35% median TTFT drop at 500k–1M (Claude Code) |
| Token cost / rate limits | Standard | Unchanged — Claude still reads full history |
| Server storage | None for your history | In-memory, encrypted; never durable disk |
| Expiry | N/A | Expire 5 min after last request; deleted ≤1 hour after last use |
| Client responsibility | Own the transcript | Own the transcript + replay on 404 |
| Beta header | None for classic Messages | message-threads-2026-08-12 |
| ZDR / HIPAA readiness | Per existing org features | Threads not ZDR or HIPAA eligible |
Limits, data retention, and availability
- Memory only: threads are held encrypted in memory under a server-managed key, never written to durable storage, and deleted no more than 1 hour after last use.
- Not ZDR / HIPAA eligible for the thread feature itself. Using threads does not strip ZDR eligibility from other features you use without threads.
- Not supported with: Message Batches, token counting requests that include
thread, compaction-on-demand, most context editing (except limited clear_thinking keep-all), orgs with HIPAA readiness enabled, orgs with Inference hooks turned on. - Distinct from Claude Managed Agents session threads — different product surface.
- Available (beta) on all models via Claude API, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), and Claude in Microsoft Foundry.
Publisher / developer checklist
- Add the beta header
message-threads-2026-08-12on every create and continue (or use the SDK thread helper). - Keep your own conversation copy from day one; design the 404 → full create replay path before production traffic.
- Omit system and tools on continue; keep fixed fields identical to create.
- Expect idle expiry — if your agent pauses >5 minutes, plan for recreate/replay.
- Do not assume cost savings — measure TTFT and request size, not “free tokens.”
- Combine with prompt caching deliberately if you want cache hits; top-level
cache_controlis a fixed field when used. - Skip threads for ZDR/HIPAA-ready orgs that cannot use this beta, or fall back to full-resend without
thread. - Do not confuse with Managed Agents session threads or with ChatGPT UI tab merges — different problems.
FAQ: Anthropic message threads
Do message threads reduce my Claude token bill?
No. Anthropic is clear that Claude still reads the full conversation each turn. Pricing and rate limits are unchanged. Threads primarily reduce request size and time to first token.
What beta header do I need?
Send anthropic-beta: message-threads-2026-08-12 on every request that uses thread. The official SDKs’ thread helpers attach it for you.
What happens if I get a 404 on continue?
Treat it as thread_not_found (confirm via error.details.error_code). Replay by sending the full conversation again with thread: {type: "create"}, then continue from the new response id. Causes include expiry, a turn the API did not store, fallback-model replies, ownership/key mismatch, and more.
Are threads durable chat history?
No. Contents live in encrypted memory, are never written to durable disk, expire 5 minutes after the last request, and are deleted within an hour of last use. Your application must keep the durable copy.
Is this the same as Claude Managed Agents session threads?
No. Anthropic’s docs call out that Messages API message threads are different from session threads in Claude Managed Agents. Message threads are a Messages API request-shape optimization for agent loops.
Does this replace OpenAI’s Chat/Work merge story?
No. OpenAI’s Chat and Work tabs merge is a ChatGPT product/UI change. Anthropic message threads are a Claude Messages API beta that shrinks later-turn payloads for long agents. Cover both as complementary industry moves toward smoother agent loops — not the same feature.
Bottom line: Anthropic’s public-beta message threads let long-running Claude agents create once and continue with deltas, cutting median TTFT roughly 35% on huge Claude Code sessions without changing token pricing. Build for short-lived in-memory threads, own your transcript, and replay on 404 — then cite the official docs when you ship. For the parallel OpenAI UX consolidation story from this morning, see ChatGPT Chat/Work tabs merge.