Anthropic speeds up Claude responses in long conversations by 35%

Long conversations with a model are handled in a less-than-elegant way: before every new response, the application sends the entire exchange again. With only a few messages in the history, this is barely noticeable. But when an agent spends hours examining a repository, operating a computer, or reading hundreds of documents, retransmitting the context becomes a separate source of latency.

Anthropic has introduced Message Threads for these scenarios. The feature has entered public beta on the Claude platform and, according to the company, cuts time to first token by about 35% for requests with contexts ranging from 500,000 to one million tokens.

What changes in the request

Imagine an agent that has already loaded a large project: source code, documentation, test results, and a history of its actions. The developer then sends a short message: “Fix the bug you found and run the tests again.”

Under the conventional approach, the client sends Claude the entire accumulated conversation again along with that message. Message Threads allows it to send only what has changed since the previous request. The model still receives the complete history, but the transport layer no longer has to push hundreds of thousands of tokens across the network again.

That is why Anthropic describes an improvement in time to first token, not a reduction in context size. The user sees the response begin sooner, but the model still reads the entire conversation and takes it into account during generation.

Where it will make a noticeable difference

Long-running agents are the primary candidates. A coding agent gradually accumulates files, compiler messages, and test results. An interface agent retains a sequence of screenshots and completed actions. A document-analysis system may keep reports, spreadsheets, and images in context. In all these cases, the new command is small compared with the history already collected.

For an ordinary chatbot with a dozen short exchanges, the difference will probably be more modest. The stated 35% applies to very large requests—from 500,000 tokens. That figure cannot be extrapolated to every conversation: the actual gain depends on the history size, network, region, model, and the rest of the application's infrastructure.

There is also an important limitation. Message Threads does not reduce token consumption: Claude still processes the full context. The feature therefore improves data-transfer latency but does not solve the cost problem of long conversations. If a task requires savings, developers will still need to trim the history, create summaries, move data into external storage, or select the context for each step more precisely.

What to check before adoption

A thread is retained between requests in encrypted memory and deleted after five minutes of inactivity. That may be sufficient for an interactive agent, but a background process with long pauses must be able to restore its state or resend the history. A thread identifier should not be treated as persistent session storage.

The feature works on the Claude platform as well as through AWS, Microsoft Foundry, and Google Cloud. While it remains in public beta, a gradual rollout is prudent: measure time to first token in your own traces, test behavior after the five-minute expiry, and provide a fallback to conventional requests.

The practical conclusion is straightforward: if your agent constantly resends hundreds of thousands of tokens of nearly unchanged context, Message Threads is worth testing. It will not make the model cheaper or improve the quality of its reasoning, but it may remove a noticeable share of the waiting time once the history has become larger than the new message.