Claude message threads: OP for the wait, Mid for the bill

Verdict, November 3, 2026. OP if you run your own agent loop on the Messages API, the next turn lands inside 5 minutes, and the wait before the first token is the problem. Mid as a way to shrink the bill. Anthropic's launch post says Claude still reads the full conversation on every turn, so token usage stays the same, and the docs say threads do not change pricing or rate limits. Mid when a person sits on the next step for longer than 5 minutes, or the org needs zero data retention. Mid as a reason to leave Cursor or Codex. The same post says threads are already on by default for most Claude Code users. That line is a vendor claim, and the November 3 Claude Code changelog does not mention it. No letter moves on the AI Coding Agents board. Claude Code stays A. S stays locked. OP or Mid has not sent a threaded request.

Pages below were read November 3, 2026.

What November 2 shipped

NEW The platform release notes for November 2, 2026 put message threads in beta on the Messages API, with the header message-threads-2026-08-12. Later requests send only the new messages. A thread expires 5 minutes after its last request and is deleted no more than 1 hour after its last use. The notes name four places: the Claude API, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), and Claude in Microsoft Foundry. They do not name Amazon Bedrock. The resources index dates the launch post November 2, 2026. Sources: release notes (opens in a new tab), launch post (opens in a new tab), resources index (opens in a new tab).

This is not a new API version. The October 22 note is the 2026-10-21 break. Threads are a beta header on /v1/messages. The docs' curl example still sends anthropic-version: 2023-06-01 plus that header. Message threads are also not session threads in Claude Managed Agents. Source: message threads (opens in a new tab).

The bill does not move

PRICE Threads do not change pricing or rate limits. The launch post says why a smaller body is not a smaller bill: Claude still reads the full conversation on every turn, so token usage stays the same. Standard token rates apply. Sources: docs (opens in a new tab), launch post (opens in a new tab).

NERF A thread does not cache the prompt. A top-level cache_control on every request is a fixed field. Send the same value each turn, or the API returns 400 thread_fingerprint_mismatch. It applies to the last cacheable block of that request's messages, once the conversation passes the minimum cacheable length. This page does not print that minimum. A request with thread can carry at most 4 cache_control breakpoints, and the top-level one counts. One too many is 400 thread_unsupported_request. The discount is still the cache math in the October 18 price note. The thread's 5 minutes is idle expiry, not that note's prompt-cache write window. Source: docs (opens in a new tab).

VENDOR CLAIM With message threads on by default for most Claude Code users, the launch post says requests of 500,000 to 1 million tokens see median time to first token drop by about 35%. It names no sample size, no date range, and no method. OP or Mid did not measure it. The November 3, 2026 section of the Claude Code changelog does not mention message threads, so that switch is not a version those notes tell you to install. Sources: launch post (opens in a new tab), Claude Code changelog (opens in a new tab).

Five minutes, then your copy

NERF A thread is best-effort. No response says whether the API stored that turn. You find out on the next continue. A miss is a 404 with error.details.error_code set to thread_not_found. A model that does not exist is also a 404, so read the code before you replay. The listed causes are expiry, a turn the API did not store (the example is a tool call cut off by max_tokens), a previous response from a fallback model, a response still generating, a different organization, workspace, user, or service account, and a new message the stored conversation cannot take, such as a first image. A workspace key, called legacy on the page, stays with that key. On Claude Platform on AWS, sign every request with credentials for the IAM role or IAM user that created the thread. Each stored response restarts the 5 minutes. Source: docs (opens in a new tab).

A review that runs past those 5 minutes pays the full upload again. Keep your own copy of every message. The SDK helper's copy lives only in memory, for as long as the helper object does, and there is no API to list, read, or delete a thread. Source: docs (opens in a new tab).

What to send

Create sends the full conversation, system, tools, and "thread": {"type": "create"}. Continue sends only the new messages, plus previous_message_id set to the previous response id. Leave system and tools out. Sending either, even as null, returns a 400. Those new messages usually start with a user turn, or with the tool_result blocks for the previous tool_use. Sending an earlier message again can duplicate it or error. Each response id can be continued once. To edit or branch, start a new thread. Source: docs (opens in a new tab).

Send these again, unchanged: model, tool_choice, thinking, mcp_servers apart from each server's authorization token, context_management, output_config, the skills in container, the top-level cache_control, and the set of anthropic-beta values. A difference is 400 thread_fingerprint_mismatch, and the message names the fields. max_tokens, stop_sequences, stream, metadata, and service_tier can change. The API does not store MCP server URLs, MCP tokens, or the container id, so send mcp_servers and container on every request that uses them. The header goes on every request. The docs say threads are in beta on every model. The example model id on the page is claude-opus-5-5. Source: docs (opens in a new tab).

first = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    system=system,
    tools=tools,
    messages=history,
    cache_control={"type": "ephemeral"},
    thread={"type": "create"},
    betas=["message-threads-2026-08-12"],
)

second = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": tool_results}],
    cache_control={"type": "ephemeral"},
    thread={"type": "continue", "previous_message_id": first.id},
    betas=["message-threads-2026-08-12"],
)

That block is the docs' request shape. history and tool_results are names. OP or Mid did not run it. client.beta.messages.thread adds the header and replays once on thread_not_found, thread_already_continued, or thread_continue_in_flight. The beta tool runner uses a thread by default. Turn it off with thread=False in Python, or thread: false in TypeScript. On a stream, continue only after message_stop. The id arrives in message_start, and an earlier continue can 404. If the stream drops first, send that continue again, then replay on thread_already_continued or thread_continue_in_flight. The helper does not retry a dropped stream. If stop_reason is "pause_turn", continue from that id with an empty messages list. A new user message while the turn is paused is rejected. On "refusal", start a new thread that leaves that turn out or rephrases it. A continue cannot remove a refused turn the API already stored. The errors in the docs' table return before the model runs, use no tokens, and do not move the expiry. Source: docs (opens in a new tab).

Who should leave the header off

NERF No Message Batches, no token counting with thread (count the full conversation instead), and no compaction on demand. Context editing is out except clear_thinking_20251015 with keep: "all". HIPAA readiness and Inference hooks are unsupported. Most of these return 400 thread_unsupported_request. When error.details.unsupported is present, it names one of context_management, cache_control, fallbacks, hipaa, or inference_hooks. An unrecognized value means send the conversation without thread. Threads are not eligible for zero data retention or for HIPAA. The API holds one in memory, encrypted under a server-managed key, never writes it to durable storage, and deletes it no more than 1 hour after its last use. Other zero data retention features stay as they were. Files are held by reference, so keep them available. A turn a fallback model wrote is not stored, and you cannot continue from its id. Send fallbacks on every request of a thread or on none. On Claude Fable 5.1, Mythos 5.1, Opus 5.5, Sonnet 5.5, and Haiku 5.5, a new thread that changes system or tools can 400 if you resend thinking or redacted_thinking blocks. Leave those blocks out. Source: docs (opens in a new tab).

The letter stays A

No letter moves. A beta header is not a new coding agent, and the 35% line is a latency claim about Claude Code traffic, not a quality score. Claude Code stays A on the AI Coding Agents list, on the October 15 placement. S stays locked. The Frontier Models list is outside this pass.

What to do today

Store every message. Create with the full history. Continue with only the new turn, the same model, and the same top-level cache_control when you want cache reads.
On a 404, replay only for thread_not_found. A missing model is a different 404. Past 5 idle minutes, budget a full resend.
Leave thread off for zero data retention, HIPAA, Inference hooks, batches, token counting, and compaction on demand.
On Claude Code, the "on by default" line is the launch post, not the November 3 changelog. Do not change harnesses for it. The October 18 price note is still how the tokens bill.

The weekly patch is on beehiiv: subscribe free (opens in a new tab).

The OP or Mid Team

Sources

Checked November 3, 2026.