Claude Code agent_summary: Does a 3-Word Status Line Really Burn 16% of Your Tokens?

If you run Claude Code with background agents, a small cosmetic feature may be eating a surprising slice of your usage. A gist published by Flamerix AI on October 28, 2026 claims Claude Code spends roughly 15 to 20 percent of its tokens generating a three-to-five word status line for each background agent, and it ships a workaround. The post hit the Hacker News front page with more than 120 points, and the replies are a useful reality check: the effect is real, but the headline number depends heavily on how you use the tool.

This is a "claimed versus verified" write-up. We did not reproduce the numbers ourselves; we read the gist, the public GitHub issue that predates it, and the Hacker News thread, and we separate what is measured from what is inferred.

TL;DR: what the claim is and how solid it looks

What is agent_summary, exactly?

According to the gist, every roughly 30 seconds, for every background agent, Claude Code sends that agent's entire transcript to the agent's own model, usually Opus, and asks it to describe its most recent action in three to five words. The answer only updates the status line in the agents panel. It never reaches the model's context or your conversation.

The gist says the behavior has been on by default since Claude Code 2.1.232 (August 2026) and that no setting turns it off. That date lines up with the public record: the GitHub feature request #86879 was filed on August 15, 2026 against version 2.1.233 and asks for exactly that, "a supported way to disable the agent_summary spinner."

The issue includes a decompiled snippet of the call. It forks the context rather than changing it, denies every tool, caps the run at one turn, writes no cache and is excluded from the transcript. The reporter's argument is that suppressing it cannot change any real turn, because every other request in the session would be byte-identical.

What was measured, and by whom

There are three separate bodies of evidence, and they are not the same experiment.

1. Flamerix AI's own telemetry. The company says its DRIM system flagged the anomaly in Claude Code's OpenTelemetry export. Grouping claude_code.api_request events by query_source, it reports that over one week agent_summary was 16.4% of all estimated spend, slightly more than the main conversation's 15.7%, and 19.7% of all API requests. About 96% of that spend was on Opus, with roughly 9,000 input tokens per output token. After installing its hook, the share dropped to 0% two days later.

An important caveat from the gist itself: "spend" here is Claude Code's own per-request cost_usd estimate, not an invoice. On a subscription, the authors note, what you lose is rate-limit headroom rather than dollars.

2. The August GitHub issue. The original reporter captured raw API bodies over a four-hour session with 27 subagents and 1,496 requests. Their table shows agent_summary at 339 calls, 22.2% of raw tokens and 18.0% of tokens weighted by Opus list rates (cache reads at 0.1x, writes at 1.25x to 2x, output at 5x). It was 22.7% of all requests in the session, producing about 21,966 output tokens in total, roughly 65 per call.

Later comments add data points. One commenter reported 15 to 22% weighted tokens in sessions with 20-plus subagents; another, on version 2.1.276, measured the share growing as a long-running subagent's context reached about 380,000 tokens. A comment from October 22 says there is still no supported switch on 2.1.300 and 2.1.301, and that the bundle contains an undocumented environment variable name whose behavior is unclear. The Flamerix gist links to this issue and says it collects "four independent measurements of 18-26%."

3. Hacker News testers. Commenters in the discussion pushed back and added nuance, covered below.

What developers are saying

The thread (129 points, 26 comments when we read it) split into three camps.

• "It is cached, so it is cheap." HeavenFox asked whether most of those tokens would be cache hits and therefore inexpensive, and simianwords made the same point. Replies were skeptical: minraws argued that even at a 90% cache discount you still pay a tenth of the input price repeatedly, and buzer noted that a five-minute cache lifetime could expire between updates. The issue's own tables are consistent with the first point: the summary calls are almost entirely cache reads, which is why the weighted share (18%) is lower than the raw-token share (22%).
• "It is smaller than 15-20%." jakozaur reported testing it: the behavior looks real but is limited to subagents, workflows do not seem affected, and in their sessions it looked like about 8% at most, mostly cache reads, cheap for short contexts and costlier for long ones. lemming replied that even 8% is hard to defend if it cannot be turned off.
• "The framing is sloppy." creamyhorror pointed out that the claim of "15-20% of your tokens" is ambiguous: of all tokens, or of tokens spent on background agents? That is a fair reading of the gist's own wording, which measures a share of one organization's Claude Code spend.
• Clarifications. quantbuilder noted that the title is misleading: it is not the terminal's bottom status line but the summary for each background agent in the agents panel, and asked whether the disableAgentView setting stops the calls. Nobody in the thread answered with a measurement.

Treat all of these as individual reports, not verified fact.

Why the number varies so much

A cream clock character placing a green bead on a curved track, a metaphor for the timer behind Claude Code agent_summary calls

The cost mechanics explain the spread between 8% and 26%.

1. Fan-out. The timer runs per active background agent. Three long-running subagents mean about six summary calls a minute, as the issue points out. One plain session means none.
2. Context length. Each call re-reads the agent's whole history. A subagent with a 20,000-token context makes a cheap summary call; one at 380,000 tokens makes an expensive one even at cache-read rates.
3. Wall-clock time, not useful work. Cost scales with how long agents stay active, so idle-but-alive background agents keep paying.
4. Cache lifetime. If the cache has expired between ticks, a call can turn from a cheap read into a full rewrite, which commenters flagged as a risk but nobody quantified.
5. Model choice. The summary uses the agent's own model, so an Opus-class agent pays Opus-class rates for decorative text.

For readers who want the broader mechanics, we covered related effects in Do subagents actually use more usage? and the agent-team token cost comparison. Anthropic's own direction of travel, folding subagents into the main loop, is covered in this explainer.

How to check your own usage

You do not need to trust anyone's percentage. Claude Code can export OpenTelemetry events, and the key attribute is query_source.

1. Enable OpenTelemetry export for Claude Code and send events to any collector you already use.
2. Filter claude_code.api_request events and group by query_source.
3. Compare agent_summary against your main conversation: request counts first, then token and cost fields.
4. Repeat on a day when you ran no background agents. If the share is near zero, you are not affected.

Remember the gist's own note that cost_usd is an estimate. If you are on a subscription plan, the practical effect is faster consumption of your five-hour and weekly limits, a topic we also followed in Anthropic's monthly API credits on Max and Team plans and the SemiAnalysis limit testing.

The workaround, and why to be careful

The gist's fix is a Bun preload script, no-agent-summary.js, about 80 lines long. Claude Code runs on Bun, and the preload wraps setTimeout and setInterval. When a timer callback's source text contains a summarizer anchor (such as the [AgentSummary] Timer fired log line), it returns an inert handle with a delay of 2 to the 31st power minus one milliseconds, because Bun and Node treat larger delays as 1 ms. Every other timer passes through. The binary itself is not modified; the script is loaded through BUN_OPTIONS=--preload.

The authors tested on Linux with versions 2.1.257 through 2.1.312. They say macOS and Windows are untested, and that on Windows the hook probably never installs. Their steps are to download the script, run claude daemon stop --any, and start Claude Code with the BUN_OPTIONS variable set. They also warn that headless runs (claude -p, cron, CI) need it too, and that daemon-spawned sessions inherit the environment of whichever client started the daemon.

Our cautions, as an independent read:

• It runs with your privileges. A preload executes inside the Claude Code process. Read the script, pin a commit rather than a moving raw URL, and avoid piping unreviewed code into your shell. That risk class is the same one we flagged in the Claude Code prompt-suggestions data claim and the coding-agent supply chain stories.
• It fails open. The match is on source text. If an update renames the log line, binds the callback, or moves the timer to another API, the summaries silently return. The gist says to re-run its verification after every update.
• It may conflict with terms or support. Patching a tool's runtime is not something a vendor supports. Whether that matters to you depends on your plan and workplace policy; we found no statement from Anthropic either way.
• Unofficial env vars are version-specific. A commenter in the GitHub issue reported that one environment variable worked on build 2.1.241 but not on 2.1.245, and another thread participant said an undocumented name in the 2.1.300 bundle has unknown behavior. Do not rely on either without testing.

Lower-risk ways to cut the cost today

If you would rather not patch anything, the options are blunt but safe.

• Run fewer long-lived background agents. The cost scales per active agent and per minute alive, so finishing agents promptly matters more than any setting.
• Keep subagent contexts short. Split long jobs into fresh agents so each summary call reads a small history.
• Prefer a cheaper model for subagents where quality allows, since the summary inherits the agent's model.
• Avoid leaving agents idle in the panel when you step away.
• Track it. A weekly OpenTelemetry query for query_source shares tells you whether any of this is worth acting on. Our session disk-space explainer and the parallel-sessions guide cover related habits.

What is confirmed, and what is not

We would revise this post if Anthropic responds in the issue, ships a documented setting, or changes the default. Until then, the fair summary is that a small cosmetic call has a measurable, workload-dependent cost, the right response is to measure it before fixing it, and an unofficial patch should be treated like any other code you let run next to your credentials.

Related reading

• Do subagents actually use more usage? Real numbers
• Agent teams vs a single agent: token cost and quality
• Anthropic folds subagents into the main agent loop
• Anthropic monthly API credits on Max and Team plans
• SemiAnalysis: Claude vs ChatGPT subscription limit testing
• Claude Code prompt suggestions and the training-data claim
• Claude Code Desktop parallel sessions guide

Version numbers, percentages and issue status are as of October 29, 2026 and come from the sources linked above; they may change with the next Claude Code release.