# Claude Message Threads: Send Only the New Messages

> Anthropic's message threads keep a Claude conversation on the server so agent loops send only new messages. How it works and its limits.

- Author: Nitish Garg, Founder & CEO, CellCog
- Published: 2026-11-02
- Canonical (HTML): https://cellcog.ai/blog/claude-message-threads/
- Section: Guides / Choosing a platform
- Publisher: CellCog (https://cellcog.ai), the AI employee platform. Blog index for agents: https://cellcog.ai/blog/llms.txt

## Key points

- Anthropic put message threads into public beta on the Messages API on November 2, 2026.
- A thread keeps the conversation on the server, so each later turn sends only the new messages and the previous response id.
- A thread expires 5 minutes after its last request and is deleted no more than 1 hour after its last use.
- Threads do not change pricing or rate limits, and they do not cache your prompt for you.
- They skip batches, token counting, compaction, HIPAA-ready organizations and zero data retention, and your app must keep its own copy.

## At a glance

- **What are Claude message threads?** A beta Messages API feature that keeps a conversation on Anthropic's server between turns, so you send only new messages and the previous response id.
- **Do they cost less?** No. Anthropic says threads do not change pricing or rate limits; the gain is a lower, steadier time to first token.
- **How long does a thread last?** It expires 5 minutes after its last request and is deleted no more than 1 hour after its last use.

Anthropic put message threads into public beta on the Messages API on November 2, 2026. A thread keeps the conversation on Anthropic's server between turns, so a long agent loop sends only its new messages and the id of the last response instead of the whole history. [@ClaudeDevs](https://x.com/ClaudeDevs/status/2117332449382510884) announced it at 19:06 UTC; the [release notes](https://platform.claude.com/docs/en/release-notes/overview) and the [message threads guide](https://platform.claude.com/docs/en/build-with-claude/message-threads) carry the details.

The pitch is speed, not price. The guide says "time to first token stays lower and steadier as the conversation grows", and states plainly that "Threads do not change pricing or rate limits." A thread is also short-lived: it expires 5 minutes after its last request and is deleted no more than 1 hour after its last use.

## How a thread works

![Animated diagram: on the left each turn uploads a growing stack of message blocks; on the right the server holds the stack and each turn sends one new block plus an id, under a 5-minute expiry timer](https://cellcog.ai/blog/media/claude-message-threads/resend.svg)
*Without a thread every turn resends the history; with one, only the new message*

The guide explains why it helps: "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. The lifecycle has three steps:

- **Create.** The first request carries the full conversation, `system` and `tools`, plus `"thread": {"type": "create"}`. The API stores the conversation, including Claude's reply, under the response id.
- **Continue.** Later requests send only the messages since the last response, plus `"type": "continue"` and that response's id. `system` and `tools` stay out; the thread keeps the values from the create request.
- **Replay.** If the thread is gone, a continue request returns a 404 with `thread_not_found`, and the app starts a new thread by sending the whole conversation again.

It needs the `message-threads-2026-08-12` beta header and works on the Claude API, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) and Claude in Microsoft Foundry. The SDKs add a thread helper that builds these requests and does the replay for you.

## What goes on each request

A thread fixes most of the request on the first turn. Anthropic splits the fields into three groups.

*Table: Message threads request fields, per Anthropic's guide (read November 2, 2026)*

| Group | Fields | Rule |
|---|---|---|
| Create-only | `system`, `tools` | Send on the create request only; sending either on a continue request returns a 400 |
| Fixed | `model`, `tool_choice`, `thinking`, `mcp_servers`, `context_management`, `output_config`, top-level `cache_control`, beta headers | Same values on every request; a change returns `thread_fingerprint_mismatch` |
| Free | `max_tokens`, `stop_sequences`, `stream`, `metadata`, `service_tier` | Can change from turn to turn |

Two details matter for anyone already using prompt caching. First, "A thread does not cache your prompt for you." Caching works as before: you place the breakpoints, or send a top-level `cache_control` on every request to cache each turn. Second, a request with a thread can carry at most 4 breakpoints, and the top-level one counts as one of them.

The API also does not store MCP server URLs, MCP authorization tokens or the container id, so those go on every request that uses them.

## What threads don't support

*Table: Features and setups that message threads don't support, per Anthropic's guide (read November 2, 2026)*

| Feature or setup | What happens |
|---|---|
| Message Batches | A batch item with `thread` ends in an `invalid_request_error` |
| Token counting | A request with `thread` returns a 400; count the full conversation instead |
| Compaction | Not available with threads; a 400 if a request sets it |
| Context editing | Not supported, except one mode (`clear_thinking_20251015` with keep all) |
| HIPAA-ready organizations | Not supported |
| Inference hooks | Not supported |
| Zero data retention | Threads are not eligible |

On retention, the guide says a thread's contents are "held in memory, encrypted under a server-managed key, never written to durable storage" and deleted within an hour of last use. There is also "no API to list, read, or delete a thread."

## The catch: your app still owns the conversation

Anthropic is direct about it: "Your application stays the source of truth for the conversation." A thread is best-effort, and no response says whether the API stored that turn; you find out on the next continue request. The guide lists the reasons a continue can fail, including an expired thread, a response cut off mid tool call by `max_tokens`, a reply written by a fallback model, or a first image in a conversation that had none.

So the work moves rather than disappears. An agent loop that uses threads still keeps every message itself and needs a replay path from day one. What it saves is upload and tokenizing time on each turn of a long conversation, which is where time to first token grows.

This sits next to other recent moves on the same problem. OpenAI added a [12-hour prompt cache](https://cellcog.ai/blog/openai-12-hour-prompt-caching/) to its Responses API in October, and Anthropic said its [Rust rewrite of the Messages API](https://cellcog.ai/blog/anthropic-messages-api-rust-rewrite/) cut time to first token by 10 to 20 percent.

## What this means if you run AI employees on Claude

Our position, declared: we build [CellCog](https://cellcog.ai/ai-employees), and every tier of our AI employees runs on Claude Opus 5.5 through the API. Long agent loops are what we run all day, so this is the kind of change we read closely. We have not said we use threads, and nothing here changes what our employees do today.

The 5-minute expiry is the number to plan around. A loop that waits on a person, a tool or a schedule for longer than that will replay the whole conversation anyway, so threads help most where turns come quickly.

## What we are watching

- **General availability.** The feature is in beta on every model today.
- **Batches and compaction.** Whether threads come to the two features they skip now.
- **Measured gains.** Anthropic gives no time-to-first-token figure for threads; independent numbers would settle how much they help.

## Sources

- Anthropic: [Message threads guide](https://platform.claude.com/docs/en/build-with-claude/message-threads) and [Claude Platform release notes](https://platform.claude.com/docs/en/release-notes/overview), November 2, 2026, read the same day.
- X: [@ClaudeDevs announcement](https://x.com/ClaudeDevs/status/2117332449382510884); time from the post id.

## FAQ

**How do I turn on message threads?**

Add the message-threads-2026-08-12 beta header and a thread field to a Messages API request: type create on the first turn, type continue with the previous message id after that.

**Do message threads replace prompt caching?**

No. A thread does not cache your prompt; you still place cache breakpoints or send a top-level cache_control, with a limit of 4 per request.

**What happens when a thread expires?**

A continue request returns a 404 with thread_not_found, and you start a new thread by sending the full conversation again. The SDK helper does this replay for you.

**Are message threads eligible for zero data retention?**

No. Anthropic holds a thread in memory, encrypted, never on durable storage, and deletes it within an hour of last use.

**Where are message threads available?**

On the Claude API, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed) and Claude in Microsoft Foundry, in beta on every model.

## Related

- [OpenAI 12-Hour Prompt Caching: When It Pays Off](https://cellcog.ai/blog/openai-12-hour-prompt-caching/index.md)
- [Anthropic Rewrote Claude's Messages API in Rust](https://cellcog.ai/blog/anthropic-messages-api-rust-rewrite/index.md)

## The AI employee for this read

[AI Software Engineer](https://cellcog.ai/ai-employees/ai-software-engineer): I built this page. For what it covers, hire an engineer: it works in your repo behind an approval gate, so nothing reaches your world unclassified.

---

Markdown alternate of https://cellcog.ai/blog/claude-message-threads/. Try CellCog free, no credit card needed: https://cellcog.ai/signup