> ## Content Index > Fetch the complete content index at: https://globalfeed.ai/llms.txt > Use this file to discover other available public pages before exploring further. # How Claude agents get faster in long conversations - URL: https://globalfeed.ai/en/how-claude-agents-get-faster-in-long-conversations/ - Published: 2026-11-03T15:53:00.000Z - Updated: 2026-11-03T15:53:00.000Z - Description: With message threads, the conversation is sent once and later turns carry only new messages. How it works, where it helps and how to try it. - Author: GlobalFeed Editor - Tags: Claude, Anthropic, API, guide, AI agents, x-Anthropic, dil-en, elle The most annoying moment with a long-running AI agent is the silence before the first word. A coding agent can send hundreds of requests in one session, and as the conversation grows, each one takes a little longer to start answering. On 2 November Anthropic [announced](https://claude.com/resources/articles/message-threads?ref=globalfeed.ai) a public beta that shortens that wait: message threads. According to the announcement, threads are already on by default for most Claude Code users, and for requests of 500k to 1M tokens the median time to first token drops by about 35%. This guide explains what the feature solves, how it works and how to try it in your own app. ## The problem: retelling the whole story every time Claude’s Messages API is stateless. You ask a question and get an answer; to ask the second one, you resend the first question, the first answer and every tool result in between. It is like reading the entire conversation back to someone each time you call them. With a short chat nobody notices. But once a coding agent piles up hundreds of file snippets, test outputs and screenshots, every request becomes a package of hundreds of thousands of tokens that the API uploads, validates and tokenizes again on every turn, all before Claude writes its first word. That wait is called time to first token (TTFT), and it shapes how responsive an agent feels more than anything else. ## How message threads work With threads, you send the full conversation once, in the first request, along with your system prompt and tools. The API keeps the conversation, including Claude’s reply, on the server for a short time under the response id. On later turns you send only the new messages and the previous response id, and the API rebuilds the conversation before calling the model. It takes one extra field: `thread`. - **Create:** the first request carries the full conversation plus `"thread": {"type": "create"}`. - **Continue:** later requests carry only new messages and `"thread": {"type": "continue", "previous_message_id": "..."}`. System and tools are left out; the thread keeps them. - **Replay:** a thread expires 5 minutes after its last request. If it can no longer be continued, you get a 404 and send the full conversation again in a new create request. One key detail: requests get smaller, but Claude still reads the full conversation on every turn. Token usage, pricing and rate limits stay the same. The gain comes from not shipping and reprocessing the whole package each time. ## Where it helps most Anthropic says the more context an agent carries, the bigger the gain. The announcement highlights long-running coding agents, where each tool result and edit adds to the conversation; computer use agents, where screenshots stay in the thread instead of being re-uploaded; and document- and image-heavy workflows. For a short chatbot the difference is small. ## How to try it The easiest path is the thread helper in Anthropic’s SDKs. It creates the thread on the first turn, sends only new messages afterwards, adds the beta header and replays the conversation once if the thread drops. The Python example from the [documentation](https://platform.claude.com/docs/en/build-with-claude/message-threads?ref=globalfeed.ai): ``` import anthropic client = anthropic.Anthropic() thread = client.beta.messages.thread( model="claude-opus-5-5", max_tokens=1024, cache_control={"type": "ephemeral"}, system="You are a support agent for Acme. Keep replies short.", ) thread.send({"role": "user", "content": "Hi! I have a question about an order."}) second = thread.send({"role": "user", "content": "How long does standard shipping usually take?"}) ``` If you build requests yourself, send the `message-threads-2026-08-12` beta header on every request. The docs split fields into three groups. System and tools go only on the create request; sending them on a continue request returns a 400 error. Fixed fields such as the model, thinking settings and the top-level cache control must keep the same value on every request, and a mismatch error names the field that differs. Fields such as max tokens and streaming can change between turns. Threads do not turn on prompt caching for you. To cache every turn, add a top-level `cache_control` as in the example. The two features work together: the thread shrinks what you send, and [prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching?ref=globalfeed.ai) reuses the part of the conversation that was already processed. A threaded request can carry at most 4 cache breakpoints. ## Rules worth knowing The docs ask your application to remain the source of truth. No response says whether the API stored that turn; you find out on the next continue request, so keep your own copy of every message and build the replay path from the start. Threads are append-only: to edit an earlier message, branch, or replace old turns with a summary, start a new thread. Each response id can be continued once. After a refusal, start a new thread rather than continuing; the SDK helper does this for you. With streaming, the response id arrives in the first event, but you should continue only after the final event. Message Batches, token counting and on-demand compaction do not work with threads yet. On data handling, the docs are explicit: a thread is held only in memory, encrypted under a server-managed key, never written to durable storage and deleted no more than an hour after its last use. The feature is not eligible for zero data retention or HIPAA, which organisations on those agreements should factor in. There is no API to list, read or delete a thread. Message threads are in beta on every Claude model, on the Claude API, Claude Platform on AWS, Microsoft Foundry and Anthropic-managed Claude models on Google Cloud. If you run long sessions, measuring time to first token with threads on and off is the quickest way to see the gain on your own workload. Sources: [Anthropic announcement](https://claude.com/resources/articles/message-threads?ref=globalfeed.ai), [Message threads docs](https://platform.claude.com/docs/en/build-with-claude/message-threads?ref=globalfeed.ai), [Prompt caching docs](https://platform.claude.com/docs/en/build-with-claude/prompt-caching?ref=globalfeed.ai)