Anthropic shipped on-demand compaction on 14 September — and the usage field your cost dashboard reads is no longer the bill

What actually shipped

Compaction itself is not new. Threshold-triggered server-side compaction has been in beta since January under the compact-2026-01-12 header: set a trigger (default 150,000 input tokens, minimum 50,000), and when the conversation crosses it the API summarises the history into an opaque compaction block, drops everything before that block on subsequent requests, and carries on.

What arrived on 14 September is control over when. From the documentation:

With the compact-2026-09-04 beta header, you can instead request a summary on demand. That request is separate from your conversation turns and returns only the summary, so it can run in the background. When the block arrives, you swap it in for the messages it summarizes.

Three things follow, and all three are genuine improvements. Summarisation stops blocking a user-facing turn. You choose the moment — after a subtask closes, rather than mid-thought at an arbitrary token count. And on models with preserved thinking, the reasoning in the turns you keep verbatim stays valid, which the threshold-triggered version could not always promise.

For anyone running long agent sessions, that is a real upgrade. It is not the part that should change what you do this week.

The note that matters

Buried in “Understanding usage” on both the Anthropic and AWS versions of the compaction page:

The top-level input_tokens and output_tokens in the usage field do not include compaction iteration usage, and reflect the sum of all non-compaction iterations. To calculate the total tokens consumed and billed for a request, sum across all entries in the usage.iterations array.

AWS adds the consequence in plain language:

If you previously relied on usage.input_tokens and usage.output_tokens for cost tracking or auditing, you will need to update your tracking logic.

Consider what those two fields are. They are the first thing every SDK example prints. They are what every cost-attribution middleware reads, what every per-customer chargeback multiplies by a rate card, what every “why did our bill jump” dashboard plots. Three years of tooling treats them as the price of the request.

They are now the price of part of the request.

Here is the shape of the response, from the documentation:

{
  "usage": {
    "input_tokens": 23000,
    "output_tokens": 1000,
    "iterations": [
      { "type": "compaction", "input_tokens": 180000, "output_tokens": 3500 },
      { "type": "message",    "input_tokens": 23000,  "output_tokens": 1000 }
    ]
  }
}

Reported at the top level: 23,000 input. Actually billed: 203,000. On Claude Opus 5 at $5 / $25 per million tokens, that is $1.13 charged against $0.14 reported — about 8x. The ratio is a property of your context shape rather than your model, because both numbers scale with the same rates; roughly, it is your trigger threshold divided by your post-summary context size.

The failure mode is worse than the number

A breaking change that throws a 400 teaches you it happened. This one returns a smaller number that looks entirely reasonable.

And it is intermittent by design. The documentation is explicit that re-applying a previous compaction block costs nothing extra and that “the top-level usage fields remain accurate in that case.” The iterations array appears only when a new compaction is triggered.

So the pattern your monitoring sees is: hundreds of correct requests, then one badly understated one, then hundreds more correct ones. That is not a step change anyone catches on a graph. It is a slow, quiet divergence between your internal accounting and Anthropic’s invoice, concentrated entirely in the requests that cost the most — which is precisely backwards from what you want if you are re-billing this to customers.

For a sense of the stakes at scale, the only fully itemised frontier agent run with public unit counts is OpenAI’s Navier-Stokes swarm, which worked out to roughly $11 per agent-hour in output tokens. An 8x undercount on the compaction-heavy fraction of a fleet that size is not a rounding error on anyone’s budget.

The documentation disagrees with itself

Worth checking rather than assuming, because it is a small thing that tells you how new this is.

Anthropic’s page prints the example above: top-level input_tokens of 23,000, matching the single non-compaction iteration, exactly as the stated rule requires.

AWS’s Bedrock page states the identical rule — top-level values “reflect the sum of all non-compaction iterations” — and then prints an example whose top-level input_tokens is 45,000, against a single message iteration of 23,000. Under the rule stated three paragraphs above it, that number should be 23,000.

One of those is a stale copy. It does not change what you are charged, and the rule itself is stated consistently in both places. It does mean that if you are implementing against the AWS page and reconciling your arithmetic to its example, you will chase a discrepancy that is not in your code. Implement against the rule, not the sample.

The break-even nobody published

The pitch for compaction is that summarising history is cheaper than re-sending it. That is true against an uncached baseline, where it pays for itself in about two turns.

Almost nobody running long agent sessions has an uncached baseline. Prompt caching is the first optimisation any serious deployment makes, and it changes the answer completely — because caching and compaction solve the same problem by opposite means, and the cheaper one caps the value of the other.

Re-reading a 180,000-token history from a warm cache costs $0.09 per turn on Opus 5, and $0.045 on Fable 5.1 after the 1 September cache read cut took that line item to $0.25 per million tokens. Against numbers that small, one compaction event — a full-price read of everything you are about to discard, plus the summary output, plus the cache rebuild the docs warn can follow — takes a while to earn back:

Assumes the 180,000 → 23,000 token shape from Anthropic’s example, list prices, a 1.25x cache write to re-establish the compacted prefix, and a context that stops growing. Real agent context keeps growing, which shifts every row in compaction’s favour — treat these as the pessimistic bound, and as evidence that the direction is not obvious rather than as a forecast for your workload.

Two things fall out. First, the cold-cache rows are not hypothetical: the default cache TTL is five minutes, and an agent waiting on a slow tool call, a human approval or a nightly job blows through that routinely. Second, and more interestingly — the better your caching, the worse compaction’s economics. Anthropic cut Fable 5.1’s cache reads to a 0.025x multiplier on 1 September, breaking its own uniform 0.1x rule to do it, and shipped on-demand compaction thirteen days later. Those two features are pulling against each other on the same model, and only one of them is going to be the right default for any given workload.

This is the same lesson as Sakana’s orchestration-token accounting: the sticker price on a model tells you very little until you know which tokens the machinery around it generates on your behalf.

Who decides when this fires

One structural point, because it determines whether any of the above is yours to control.

If you call the Messages API directly, the trigger threshold, the summarisation prompt and now the timing are all yours. That is the good case — the arithmetic above becomes a decision you can make.

If you are inside a managed harness, it is not. When OpenAI put the Agents API into public beta on 10 September, the harness came free and owned compaction, recovery and subagent spawning — every one of those decisions denominated in tokens sold by the company that wrote the policy. Anthropic has just made the equivalent decision explicitly configurable on its raw API while Claude Code users get whatever the harness decides. That gap between the API and the product built on it is the same one Google drew a line through this week when it gave its engineers the model but not the harness.

It also lands in a week where Anthropic’s roughly 80% inference margin went public. None of this is evidence of bad faith — the feature is documented, the note is there, the rule is stated twice. But when a vendor’s margin is that healthy and a billing field quietly stops meaning what it meant, the reasonable posture is to verify your own numbers rather than inherit theirs.

What to do with this

1. Fix your cost tracking before you enable compaction. Sum usage.iterations when present; fall back to the top-level fields when it is absent. This is a ten-line change and it is the entire actionable content of this story.
2. Audit whether compaction is already on. Threshold-triggered compaction has been available since January. If a team enabled it behind compact-2026-01-12 and your finance reconciliation has drifted since, you now know where to look.
3. Do not enable compaction as a cost optimisation without running the table above on your own numbers. Against good caching it can lose. Against a context ceiling it always wins, because the alternative is a failed request.
4. Check platform parity before you design around it. The Claude API supports compaction on eleven models; Bedrock’s page lists two, and not on the Converse API. Confirm for the platform you will deploy on.
5. Instrument the compaction rate itself, not just tokens. A rising number of compaction events per session is the leading indicator that context is growing faster than the work is — the same signal worth watching on any metered harness, and one the top-level usage fields will never show you.

If you are choosing where to run long agent sessions, the best AI agent tools rundown covers the orchestration layer and best AI harnesses covers the loop itself; best AI coding tools tracks the seat-priced products built on top. For the models and rate cards underneath, the Claude review tracks Anthropic’s tiers and what they cost, and Cursor and GitHub Copilot track the two harnesses most likely to be making these decisions on your behalf. For the other direction the meter has been moving this month, see GPT-Live-1’s switch from token billing to flat per-minute voice.

Questions or corrections? Email Pick Right. Want the full list? See all news.