Claude Code agent summaries: 2% to 16% of spend

Title card reading Your agent summaries have a price tag, with the Claude Code mark top left and a gold-outlined terminal window of three glowing agent transcripts whose lines converge into one small status chip circled by a refresh loop.

Every background agent you run in Claude Code has a second, quieter conversation going on beside it. About every 30 seconds while the agent works, Claude Code sends that agent’s transcript back to the model to write a status line of a few words. That status line cost one team 16.4% of its Claude Code spend in a week, while Anthropic says the average across its telemetry is about 2%, so the only number that matters is your own. A week of OpenTelemetry data will tell you. This post covers what the call does, why the two figures differ, how to measure your share, and the levers that exist today.

Each active background agent pays for its own status line

The mechanism was reverse engineered in a gist by the Flamerix team, and when it reached Hacker News on October 29, an engineer on the Claude Code team confirmed the basic shape about 80 minutes later. For every background agent that is actively working, a timer fires roughly every 30 seconds. Claude Code then sends the agent’s whole transcript to the agent’s own model with an instruction to “describe your most recent action in 3-5 words”, and puts the answer in the agents panel. The gist says the answer “never reaches the model or your conversation”; the engineer’s reply adds that Claude Code itself uses the summaries to track what each agent is doing without reading its transcript. Either way, the output is one short line.

So the call reads the largest object in the session to produce the smallest one. In the gist’s week, the ratio was about 9,000 input tokens per output token, and 96% of the summary spend ran on Opus, because the summary uses whatever model the agent itself runs. Two more details from the gist matter. The interval is set by a server flag and clamped between 30 and 240 seconds, with the default at the minimum, so you cannot tune it yourself. And “These requests are not written to the session logs on disk”, so a tool that reads local session files will never show them.

This is not the same feature as the row summaries in Claude Code’s agent view, which Anthropic documents as a Haiku-class request at the end of each turn plus an occasional rewrite during long turns. The call in question here is per agent, on a timer, on the agent’s own model.

Flow diagram: an active background agent's whole transcript goes every 30 seconds to the agent's own model, which returns three to five words to the agents panel; an idle agent sends nothing, a warm cache makes the call a cheap read and a cold one a full write. — The summary call: the whole transcript in, a few words out, on a timer, for every agent that is working.

Why one team measured 16.4% and Anthropic measured 2%

Both numbers can be true. The Flamerix figures come from one team over one measured week, in which agent_summary was 16.4% of their estimated spend against 15.7% for the main conversation, and 19.7% of all API requests. Their spend is Claude Code’s own per-request estimate, not an invoice, and on a subscription what you lose is rate-limit headroom rather than dollars.

The engineer answered in the Hacker News thread that reached 583 points: “Last week, across Claude Code users who send us telemetry, agent_summary was about 2% of cost at API list prices and just under 4% of requests.” The same comment narrows it to about 6% of cost in the terminal, where nearly all of these calls happen. It also adds the condition that explains the spread, which is that only actively working agents get the call.

So your share depends on how you work. A developer who runs one conversation and rarely backgrounds anything sits near zero. A team that fans work out to several agents running for minutes at a time sits at the far end, and the thread fills in the middle, with one user at around 3% across a whole company, another at 8% at most, and several at 15% or more. The summary tax scales with agent-minutes of parallel work, so the teams that adopted background agents hardest pay the most.

What changed: the engineer wrote “we agree that’s a lot for a status line”, said a fix for summaries that miss the prompt cache shipped in 2.1.311, and said a cheaper mode that sends short notes to a smaller model is in progress. The public changelog up to 2.1.316 does not list either item yet.

The cache decides whether a summary is cheap or expensive

Do the arithmetic once with your own transcript sizes. The gist reports that about 98% of summary calls re-read the transcript from cache, and that the roughly 2% that hit a cold cache carry over a third of the cost. Anthropic’s pricing page shows why. On Opus 5.5, the model we use for the example, a cache hit costs $0.20 per million input tokens, while a five-minute cache write costs $5.

Take an agent whose transcript has grown to 150,000 tokens. A warm summary call reads it for about $0.03; a cold one writes it for about $0.75, twenty-five times more. At two calls a minute that is about $3.60 an hour per active agent if every call is warm. Weight it 98 to 2 and the expected cost per call is about $0.044, of which the cold calls are $0.015, or 34%. That is the same “over a third” the gist measured. Four agents working in parallel for an hour lands near $21 of summaries at list prices.

The cache has been the lever for a while. The Claude Code changelog for 2.1.128 already carried two fixes: sub-agent progress summaries missing the prompt cache, with a 3x reduction in cache creation, and summaries firing repeatedly while an agent’s transcript was static. If you pin an old version for stability, check which side of those fixes you are on.

Claude Code exports OpenTelemetry metrics and events of its own, documented on the monitoring usage page. The trap is that the convenient metric is too coarse. On the cost counter, query_source is one of three categories, main, subagent or auxiliary, so the summary calls disappear into a bucket. The detail lives on the per-request event, which only exports when the logs exporter is on:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

Each claude_code.api_request event carries query_source, cost_usd, and the input, output and cache token counts, including cache writes split by lifetime since 2.1.300. Group a week of events by query_source and sum cost_usd, and the agent_summary row against the total is your number. The Flamerix team found theirs exactly this way, and it is the same shape as the per-feature attribution we described in LangChain token cost attribution, applied to a tool instead of your own app.

Two notes on reading it. The Claude Code docs list example values for the event’s query_source but never name agent_summary, so confirm the value in your own data before you build a dashboard on it. And cost_usd is an estimate at list prices, so on a subscription read the share as the slice of your rate limit going to status lines. If you already run LLM observability for your production agents, this belongs in the same backend; AI FinOps starts with knowing which subsystem spent the money.

The levers you have today, and what each one costs you

No documented setting turns off only the summaries. We checked the environment variables reference, the settings reference and the changelog through 2.1.316, and none mentions them. Here is what exists.

Lever	Stops summary calls	What you give up	Status
Update to 2.1.311 or later	No, makes cold misses rarer	Nothing	Anthropic’s HN comment; not in the changelog
Fewer agents working at once	Fewer, in proportion	Parallelism	Your call
Turn background tasks off	Yes, per the gist	Background subagents, Ctrl+B, background shell commands	Documented variable
Turn fork mode off	Yes, per the gist	Forks that inherit the conversation and cache	Documented variable
A preload hook from the gist	Yes	Agents panel status stops updating	Third party, may break on update

The two documented switches, as they appear in the reference:

# blocks run_in_background for subagents and shell
export CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1
# fork mode is on by default
export CLAUDE_CODE_FORK_SUBAGENT=0

Both are blunt. They remove the feature that generates the cost, and the subagents docs state that with background tasks off, Claude waits for subagents to finish before it continues. The Agent SDK reference documents an agentProgressSummaries option that defaults to false, but the gist’s reading of the bundle is that the option and its undocumented environment variable can only switch summaries on. The same gist found that headless claude -p runs do not arm the timer by default and puts the default-on overhead in interactive sessions with background agents.

The gist’s preload hook does work in their tests, from 2.1.257 to 2.1.312 with zero summary calls after, but it hooks the running binary from outside, an update can silently undo it, and you are trusting a third-party script with your coding agent. We would not roll it out to a team without reading every line, and we would keep the telemetry check on regardless.

How we budget agent-minutes in our own runs

Our scheduled agent runs delegate in the open: a run that writes one post starts a topic picker, a researcher and a reviewer, each as a background subagent with a hard time ceiling. In the run that produced this post, the picker worked for 145 seconds and the researcher for 184, by the run’s own agent log. In an interactive session with the timer armed, that would be about five and six summary calls, each re-reading a transcript that grows with every page the agent fetched.

So we treat agent-minutes as a budget line in the same way we treat cost per task: delegate when the work runs in parallel or is large, and keep short lookups in the main thread, where they cost one read instead of a read plus a status line every half minute. It is the same discipline as the one behind how we halved Claude Code token usage with RTK, where the cheapest tokens were the ones that never entered a context. For a coding agent fleet, the question to put to every background agent is whether you would pay for its status line on its own.

When the status line is worth paying for

Anthropic’s case for the feature is real. The engineer’s comment says the summaries let both you and Claude Code track what each background agent is doing without reading transcripts, and in a long agentic coding session with several agents in flight, a current one-line status is how you notice an agent going sideways before it burns twenty minutes. If you supervise parallel agents by glancing at the panel, at 2% to 6% the status line is a fair price for that.

The cost becomes a problem in the opposite pattern: agents left working unattended for long stretches, with large transcripts and nobody watching the panel. That is where the 16% lives. Measure first, then decide which pattern is yours.

The takeaway

Claude Code’s background agent summaries are a real, measurable line item, about 2% of cost on average by Anthropic’s telemetry, about 6% in the terminal, and 16.4% for one team that runs agents hard. Turn on the OpenTelemetry logs exporter, group claude_code.api_request events by query_source, and you will know your number within a week. Then pick a lever. Update past 2.1.311, run fewer agents at once, or turn off background tasks if you never look at the panel. For the other half of the token bill, start with how we cache prompts in production.