Claude Code Message Threads Cut Long-Session Lag 35%, Not Costs

What Anthropic shipped

Anthropic has put message threads into public beta on its Messages API. With threads, an agent no longer has to upload its entire conversation history on every turn. The first request carries the full context, including the system prompt and tool definitions. After that, each request carries only the new messages plus the ID of Claude's previous response, and Anthropic's servers rebuild the rest.26 The company says threads are already on by default for most Claude Code users, so developers on its flagship coding agent get the change without doing anything.23

Anthropic's main claim is about time to first token (TTFT). For Claude Code requests between 500,000 and 1 million tokens, it says the median wait before Claude starts responding is about 35% shorter.29 Anthropic's developer account added a second figure: in long conversations, the median request shrank from roughly 800 KB to 1.8 KB.7

The headline caveat is the same in every report: the bill does not change. Claude still reads the whole conversation on every turn. A 500,000-token history is still 500,000 tokens of input, even though the client only sent the latest messages.2 Anthropic's documentation says threads do not change pricing or rate limits.8

How it works, and the five-minute catch

In practice, threads work like a short-lived server-side cache. Threads are held encrypted in memory, never written to disk, and expire five minutes after the last request.610 According to the documentation, a thread is deleted no more than an hour after it was last used.8 When a client tries to continue an expired thread, it gets a 404 error and has to resend the full conversation to start a new one.12

The five-minute limit sounds harsh for a feature aimed at long sessions, but it matters less than it seems. Each successful request resets the timer, so an agent making regular calls keeps its thread alive for the whole task. If a developer walks away for a coffee, the SDK helper replays the history when they return. The first request after the break is slower, but no context is lost.25

The sharper problems are for teams building their own agents. The API does not check new messages against what it has stored, so a duplicated message can end up in the conversation twice. Each response ID can only be continued once, and threads are append-only, so editing or branching an earlier turn means starting over.8 The SDK helper only keeps the conversation while the helper object exists. Agents running as serverless functions or queue workers therefore need to save their messages themselves.8 Changing the model or reasoning settings mid-session also breaks the thread and returns a fingerprint-mismatch error.1

Some customers can't use threads at all yet. The feature is not eligible for zero data retention or HIPAA, and it doesn't work with on-demand compaction, Message Batches or token counting.28 Threads work on the native Claude API, Claude Platform on AWS, Claude in Microsoft Foundry and Anthropic-managed Claude models on Google Cloud.23 Amazon Bedrock is not on the official list.1

Where the coverage agrees and where it doesn't

The reports agree on the basics: the 35% median, the 500K-to-1M-token range, the five-minute expiry and the unchanged pricing.349 They differ mainly on how much to read into the numbers.

One detailed explainer points out that the 800 KB-to-1.8 KB figure doesn't appear in Anthropic's blog post or documentation. It notes that the "400 times smaller" claim circulating on social media is a rounded version of a ratio closer to 444.1 The figure does come from Anthropic's own developer account, though, so it is a company claim, not a rumour.7 That explainer also found no mention of threads in the public Claude Code changelog. That fits with a server-side switch that needs no minimum client version.1

The most useful reality check comes from ZDNET, which applied Anthropic's 35% figure to its own Claude Code logs. In very large contexts, the first token usually arrived about three seconds after a mid-task request. Across four-hour sessions with 100 to 225 model calls, the projected saving was two to four minutes per session.26 That is real but modest, and it is a projection, not a measured benchmark. Several outlets also note that no independent test has yet reproduced Anthropic's median.18

The best reading of all this: threads are a meaningful fix for people who keep Claude Code running for hours on large codebases. They won't matter much to someone who asks a few short questions a day.

Part of a steady push on latency

Threads continue a run of speed work from Anthropic. In mid-October, Claude Code started gzip-compressing the conversation it sends each turn, and cloud sessions began starting up as soon as the user starts typing.27 Anthropic's charts show the p90 wait before the first token in local Claude Code sessions dropping from 4.07 to 1.33 seconds between August and October. Cloud sessions fell from 16.99 to 6.00 seconds.22 Those figures exclude time spent in the model itself, so they measure the overhead around inference rather than the model getting faster.24

Gzip makes each upload smaller. Threads skip most of the upload altogether.1 Neither changes what the model has to process.

That sets threads apart from Claude Code's fast mode, which goes after a different bottleneck and costs more. Fast mode makes Opus generate output up to 2.5 times faster at a higher per-token price: $8/$40 per million input/output tokens on Opus 5.5.21 That is double the standard rate, and it doesn't shorten time to first token.25 Developers who care about speed now have three separate levers: compression and threads for upload overhead, fast mode for generation speed, and prompt caching for cost.124

The cost point is where readers most often get confused. Threads alone don't cache anything. Teams that want lower bills have to turn on prompt caching alongside them, keeping the same top-level cache_control setting on every request.1 That matters more now that Anthropic cut cache prices by 75% in September.9

The idea isn't new across the industry. OpenAI's Responses API lets clients chain requests with a previous_response_id, storing responses for 30 days by default. Google's Interactions API uses previous_interaction_id, with up to 55 days of storage on paid plans. Both still bill the full history as input.1 Anthropic's version keeps state for far less time. For enterprise buyers worried about data retention, that short life may be the selling point.

The competitive backdrop: Copilot goes multi-agent

The timing matters. A week earlier, at GitHub Universe, GitHub recast Copilot as a platform for coordinating fleets of agents. It launched a revamped Copilot app, Copilot Projects for running agents in parallel across repositories, and the Copilot Fusion model router.1216 GitHub's Octoverse data says agents wrote the first draft of more than 40% of pull requests in September, up from 17% in March.16

Code review is where that volume of agent-written code piles up. GitHub added Max, a public-preview review level that runs several independent review agents on models from different providers. An aggregation agent then reconciles their findings.11 Copilot approvals, which count toward a repository's required approvals, are now generally available. They are off by default, and any new commit dismisses them.11 On cost, the coverage differs. InfoWorld cites GitHub estimates of about $0.25 per Lite review, $1.50 per Balanced review and $10 per Max review.12 Data Studios found the documentation listing only ranges for Lite and Balanced and no published figure for Max.13

GitHub's claims about review quality also need some care. Its ReviewBench benchmark, which it built with Microsoft, puts Copilot at the top. But GitHub's own team ran the competitors' initial entries, and Martian's independent leaderboards ranked Copilot fourth and fifth.18

The two companies' releases point in different directions. GitHub is selling breadth: more agents, more models and more automated sign-off, with usage-based billing behind it.16 Anthropic is improving the experience of a single long-running agent. One reading is that threads are Anthropic's answer to developers who keep sessions open for hours, where responsiveness decides whether a tool feels like a collaborator or a queue.

Both approaches leave the same problem unsolved. Faster agents and multi-model reviewers both add up to a bigger bill, and only GitHub has put a price on its premium tier. Analysts already warn that ten parallel agents means ten pull requests to review, test and pay for.12 Message threads cut the wait, not the workload, and they don't touch the cost.