One request, no reply

Anthropic’s API will now write the summary itself and hand back a signed block that replaces the messages

A beta dated 14 September adds a compaction parameter: send the conversation, get one block and no answer, then send the block first. Leave the old messages in front of it and the next call is an HTTP 400.

Threshold, compact-2026-01-12On demand, compact-2026-09-04
Wheninput tokens cross a value you set, 50,000 or morewhenever you send compaction: {type: summarize}
What comes backa reply, with a compaction block inside itone signed block, no reply, stop_reason compaction
Where the block goesafter the messages it summarisesfirst, in place of them
Runs in the backgroundnoyes, on a separate request
Keeps recent turns verbatimnoyes, if you append them after the block
WhereClaude API and cloud platformsClaude API only
Two ways to compact on the Claude API, as the compaction guide describes them.

Anthropic’s Messages API now returns a signed compaction block on request and no reply with it, under a beta header dated 14 September.

It is the first compaction a caller controls. The threshold version that has run since January decides for you; this one waits to be asked, and its block can be swapped in behind a conversation still in flight.

The mechanics are in the guide. Send the conversation as it stands with a top-level compaction parameter of type summarize. The API “summarizes every message in the request once, generates no reply after it, and returns the block alone with stop_reason compaction”. The block carries a signature. On every later request it goes first in the messages array, “in place of the messages it summarizes”, followed by any turns since. The guide is explicit about the failure: leaving the summarised messages in front of a signed block “is a 400 error”, an HTTP 400 rather than a warning.

Because the summarising request is separate from the conversation’s turns, it can run in the background while the live conversation continues on its full history, and the block is swapped in when it arrives. Recent turns can be kept word for word after the summary, and on models with preserved thinking the guide says the thinking in those kept turns “can stay valid” after the swap, provided the system prompt and tools on the summarising call match the ones in use.

It is billed as a request. The response’s top-level input_tokens and output_tokens read zero, and the cost appears under usage.iterations as a compaction entry; the guide’s example shows 144 tokens in and 276 out for a three-message conversation. max_tokens caps the whole call including any thinking before the summary, so the guide says to “allow several thousand tokens”. The summariser reads your tool definitions and never runs one.

Three limits sit in the guide’s own text. The conversation “must still fit the model’s context window, so compact before you outgrow it, not after”. You cannot combine the compaction parameter with context_management on one request. And it is available on the Claude API only, on eleven listed models from Claude Sonnet 4.6 to Claude Fable 5.1, not on Bedrock, Vertex or Foundry.

The concession is that a client-side summariser already does all of this, and cheaper if it uses a small model. It holds on price and fails on the signature: a block the API signed is one the API will trust to carry preserved thinking across the swap, and a summary you wrote yourself is a user message.

The paper’s verdict: any agent loop that already pauses to compact should move to this and stop pausing. Anything running on a cloud platform waits, and the release notes give no date for that.

What it changes If your agent loop compacts by hand, switch to compaction: {type: summarize} on a background request and swap the signed block in; remove the summarised messages or the next call fails with a 400. On Bedrock, Vertex or Foundry, nothing changes yet.

Primary source read

Who is telling you this

Anthropic · primary

Written by
Not published on the page
For
Anthropic
What they gain if this is true
The paper’s best guess: the vendor, whose API bills the summarising request; the guide states the billing plainly, which is the fact a reader most needs.

Published in the edition of Wednesday, 16 September 2026 · Beat: Models