# Claude Code status line token usage: the status line is free, agent_summary and startup context are not

> Source: <https://stackness.dev/blog/claude-code-status-line-token-usage-agent-summary-and-startup-overhead>
> Published: 2026-11-01 19:32:07+00:00

# Claude Code status line token usage: the status line is free, agent_summary and startup context are not

The [Claude Code](https://stackness.dev/tools/claude-code) status line uses no model tokens: the [docs](https://code.claude.com/docs/en/statusline) say it "runs locally and does not consume API tokens". The cost behind this week's "3-word status line" headline is `agent_summary`, a separate call that labels each working background agent in the agents panel. Flamerix AI measured it at 16.4% of one organisation's weekly Claude Code spend. Anthropic puts it at about 2% of cost across its telemetry users, and users who measured their own subagent-heavy sessions report 8% to 26% of spend or tokens. Before any of that, my own setup carried 43,394 tokens of context into a one-word reply on Claude Code 2.1.316, measured on 1 November 2026.

## Claude Code status line token usage is zero; three other things cost tokens

Claude Code's custom status line costs no tokens because it is a local script: Claude Code pipes session JSON to it on stdin and prints whatever it returns. Three things do cost tokens before or beside your instructions: the startup context sent with every request, `agent_summary` calls for background agents, and side calls such as session titles, recaps and prompt suggestions. The table puts a measured number on each.

| Overhead | When it runs | Measured size | Source | 
|---|---|---|---|
| Status line script | Each new message, 300 ms debounce | 0 tokens | [Statusline docs](https://code.claude.com/docs/en/statusline) | 
| Startup context | Every request, mostly as cache reads | 2,102 to 64,887 tokens per request | My runs, 1 November 2026 | 
| `agent_summary` | About every 30 s per working background agent | 2% to 24% of spend, up to 26% of tokens | Anthropic, Flamerix, users | 
| Session title | First prompt of an interactive session | One small Haiku-class request | [Sessions docs](https://code.claude.com/docs/en/sessions) | 
| Recap, prompt suggestions, idle compaction | Idle time, after each reply, after an hour away | Suggestions: 2.5% of weighted tokens in [one session](https://github.com/anthropics/claude-code/issues/86879) ; recap and idle compaction unmeasured | [Costs docs](https://code.claude.com/docs/en/costs) | 

## agent_summary sends a background agent's transcript every 30 seconds

`agent_summary` is the call that writes the 3-5 word label next to each background subagent in Claude Code's agents panel. About every 30 seconds, for each background agent still working, Claude Code forks that agent's conversation and sends it to the agent's own model with one instruction: describe the most recent action in 3-5 words. An Opus subagent is summarised by Opus, a Haiku subagent by Haiku.

The [Flamerix gist](https://gist.github.com/flamerix-ai/c3905705cc4205e5de3011fa2e74efce), first committed on 28 October and on the [Hacker News front page](https://news.ycombinator.com/item?id=50284255) the next day with 584 points, says the behaviour has been on by default for interactive background agents since 2.1.232 (13 August 2026); the [changelog](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md) for that version does not mention it. Headless `claude -p` runs skip it unless the undocumented `CLAUDE_CODE_AGENT_PROGRESS_SUMMARIES` is set. Since 2.1.128 a tick is skipped when the transcript has not changed.

Most of each call is a cache read, $0.20 per million tokens on Opus 5.5 against $4 uncached ([pricing](https://platform.claude.com/docs/en/about-claude/pricing)). A 100,000-token transcript summarised 120 times an hour is 12 million cache-read tokens: $2.40 per agent-hour on Opus 5.5, and $0.60 on Haiku 5.5, whose prompts above 100,000 tokens cost five times more. A call that misses the cache pays the uncached rate, about 20 times as much, and Flamerix found the 2% of calls that missed carried over a third of the cost.

The code in my installed 2.1.316 still runs on a 30,000 ms timer. A server-side flag picks between the default `full` mode, which forks the whole transcript, and a `short` mode that sends about 2,000 tokens of notes to a writer model. That matches [Anthropic's reply](https://news.ycombinator.com/item?id=50284699) on Hacker News, which says a fix for cache-missing summaries shipped in 2.1.311 and a cheaper notes mode is in the works; neither is in the changelog.

I repeated the gist's controlled test on 2.1.316: one Haiku 5.5 background subagent running eight 20-second `sleep` commands, with summaries forced on, then left at the headless default. The first run made 5 summary calls, 31 seconds apart, each reading about 35,000 tokens; the second made none. The five calls cost about $0.0037 at list price, 20% of their run's $0.018, and the first one missed the cache.

## Measured agent_summary shares run from 2% to 24% of spend

The share of Claude Code spend that goes to `agent_summary` depends on how many background agents a session runs. Anthropic's 2% averages every telemetry user, including people who never start a background agent; the 16.4% and the user numbers come from teams running many long subagents, who are the ones who went looking. All figures are self-reported, and only Anthropic's covers more than one team.

| Who | Version | Sample | Share | 
|---|---|---|---|
| [Anthropic (edwinarbus)](https://news.ycombinator.com/item?id=50284699) | not stated | Telemetry users, week before 29 Oct | ~2% of cost, under 4% of requests; ~6% of cost in the terminal | 
| [Flamerix AI](https://gist.github.com/flamerix-ai/c3905705cc4205e5de3011fa2e74efce) | to 2.1.301 | One organisation, one week, size not given | 16.4% of estimated spend, 19.7% of requests | 
| [rflcrz](https://github.com/anthropics/claude-code/issues/86879) | 2.1.233 | 1 session, 4 h, 27 subagents | 18.0% of weighted tokens, 22.7% of requests | 
| [sylvain-artois](https://github.com/anthropics/claude-code/issues/86879#issuecomment-5730931355) | 2.1.276 | 1 session, 1 h 45 min, 4 subagents | 26% of cache-read tokens | 
| [chrisvaillancourt](https://github.com/anthropics/claude-code/issues/86879#issuecomment-6509552460) | 2.1.312 | 30 days, 129 sessions | ~10% of spend, 24% in a 40-agent session | 
| [jakozaur](https://news.ycombinator.com/item?id=50284683) | not stated | Own sessions | "~8% at most" | 

On a subscription none of this is a bill; it comes out of the five-hour and weekly limits.

## A one-word reply carried 2,102 to 64,887 tokens on my machine

Claude Code's startup context is the system prompt, tool definitions, CLAUDE.md files, memory, the skills listing and MCP server instructions, sent with every request. I asked Claude Code 2.1.316 to reply "OK" in six configurations with `claude -p --output-format json --model sonnet` and added the input, cache-write and cache-read counts it reported.

| Configuration | Context tokens | First-call cost (Sonnet 5.5) | 
|---|---|---|
| `--safe-mode --tools ""` : no tools, no customisations | 2,102 | $0.006 | 
| `--safe-mode` : built-in tools only | 16,222 | $0.021 | 
| Full setup, MCP servers and skills off | 34,420 | $0.061 | 
| Full setup, no MCP servers ( `--strict-mcp-config` ) | 39,144 | $0.102 | 
| Full setup in an empty folder | 43,394 | $0.129 | 
| Full setup in the Stackness repository | 64,887 | $0.215 | 

Built-in tool definitions are the biggest block at 14,120 tokens. My 20 MCP servers add only about 4,250, because Claude Code [defers MCP tool definitions](https://code.claude.com/docs/en/costs) until a tool is used; the skills listing adds about 4,700 and the Stackness CLAUDE.md and project memory 21,493. After the first request it is all cache reads: 43,394 tokens cost about $0.004 a request on Sonnet 5.5 and $0.009 on Opus 5.5.

## Measure your own overhead with /context, OpenTelemetry and a debug log

Claude Code offers three ways to see what it sends besides your words, and transcript readers such as [ccusage](https://stackness.dev/tools/ccusage) are not one of them: summary forks are never written to the session files under `~/.claude/projects/`, as [issue #104358](https://github.com/anthropics/claude-code/issues/104358) documents. `/context` shows the startup context by category, and `/context all` lists each item.

`claude -p --output-format json` prints `usage` and `modelUsage`; in my test, `modelUsage` included the summary calls. [OpenTelemetry](https://stackness.dev/tools/opentelemetry) is the only documented way to see each `agent_summary` request on its own: group the `claude_code.api_request` events by `query_source`. Without a collector, the debug log works, though its lines are internal and can change:

```
claude --debug-file /tmp/cc-debug.log
grep -c '\[AgentSummary\] Forking' /tmp/cc-debug.log
```

A logging proxy such as [LiteLLM](https://stackness.dev/tools/litellm) also sees every side call; the [proxy setup post](https://stackness.dev/blog/run-your-own-llm-proxy-to-track-token-usage-litellm-claude-code-codex) covers it.

## The switches that turn each overhead off, and what each one costs

Claude Code has no documented switch for `agent_summary`, and `DISABLE_NON_ESSENTIAL_MODEL_CALLS`, which the gist says some packagers set, is in neither the docs nor the changelog. The documented switches below are in the [environment variable](https://code.claude.com/docs/en/env-vars), [settings](https://code.claude.com/docs/en/settings-reference) and [CLI](https://code.claude.com/docs/en/cli-reference) references as of 1 November 2026; auto-compaction's is spelled `DISABLE_AUTO_COMPACT`.

| Overhead | Switch | What you lose | 
|---|---|---|
| `agent_summary` | `CLAUDE_CODE_FORK_SUBAGENT=0` | Fork mode. Two users measured summaries stopping and two more reported it; one saw no change. Forks and `context: fork` skills are still summarised | 
| `agent_summary` | `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1` | All background agents | 
| `agent_summary` | Flamerix's [Bun](https://stackness.dev/tools/bun) preload via`BUN_OPTIONS` | Panel labels; third-party code, and its v3 gate fails on Windows | 
| Session title | `CLAUDE_CODE_DISABLE_TERMINAL_TITLE=1` | Terminal title and status reports | 
| Recap, suggestions, idle compaction | `awaySummaryEnabled` ,`promptSuggestionEnabled` ,`idleCompaction` set to`false` | Each feature; without idle compaction the first message after a break re-reads the context at the miss price | 
| MCP and skills context | `--strict-mcp-config` ,`--disable-slash-commands` | MCP servers not passed with `--mcp-config` ; all skills | 
| Most startup context | `--bare` | Hooks, skills, plugins, CLAUDE.md, background agents; needs `ANTHROPIC_API_KEY` , so not on a subscription | 

The labels may matter beyond the panel: Anthropic's reply says summaries are used by "both you and Claude Code", and one reader of the 2.1.314 code [reported](https://gist.github.com/flamerix-ai/c3905705cc4205e5de3011fa2e74efce) they can reach a running agent's context. Nobody has measured a quality change from turning them off.

## Token optimizer claims against independent checks

Of the token optimizer tools in this week's threads, I found an independent check only for [Caveman](https://stackness.dev/tools/caveman), and none of them touches `agent_summary`. JetBrains [ran Caveman on SkillsBench](https://blog.jetbrains.com/ai/2026/07/speak-to-ai-agents-like-cavemen-tosave-tokens/) in July: "Advertised saving: 65%. Measured saving: 8.5%", with no significant quality change.

[claude-token-optimizer](https://stackness.dev/tools/claude-token-optimizer) claims 90% from its author's one project; its scanner counts Markdown files under `docs/` as auto-loaded, which Claude Code does not do, and it counts with a tokenizer whose README says it "is no longer accurate" for Claude 3 and later. The [dev.to MCP post](https://dev.to/aws-builders/mcp-token-cost-i-cut-my-mcp-server-from-15-tools-to-4-cek) cut tool descriptions by 88%, counted in characters, in one run in [Kiro](https://stackness.dev/tools/kiro).

## My numbers against Systima and Anthropic

My 16,222-token safe-mode figure is half the most-cited startup measurement: Systima [measured about 32,800 tokens](https://systima.ai/blog/claude-code-vs-opencode-token-overhead) on Claude Code 2.1.207 in July 2026, against about 6,900 for [OpenCode](https://stackness.dev/tools/opencode), most of it tool definitions. Neither run had MCP servers, so the gap is in the two fixed blocks: tool definitions, 14,120 tokens in 2.1.316 against Systima's roughly 24,000, and the system prompt, 2,102 against 6,500. Systima's 72 KB CLAUDE.md added a little over 20,000 tokens, close to the 21,493 the Stackness repository adds.

For `agent_summary`, Anthropic's telemetry is the only large sample; everyone else measured their own heavy sessions. On Stackness, as of 1 November 2026, Claude Code is on 8 real public stacks and Bun on 2 ([how I count](https://stackness.dev/about/data-sources)), among the [AI coding tools developers list](https://stackness.dev/categories/ai-tools).

## Method and sample

I ran Claude Code 2.1.316 on macOS on 1 November 2026 on a subscription, with `--model sonnet` and `--no-session-persistence`, once per configuration. Context tokens are `input_tokens` plus `cache_creation_input_tokens` plus `cache_read_input_tokens`, and costs are Claude Code's own list-price `total_cost_usd`. My setup has 20 MCP servers, a dozen plugins and a long global CLAUDE.md, the heavy end; a fresh install sits near the safe-mode row.

The summary test ran `claude -p --model haiku --debug-file` twice and counted `[AgentSummary] Forking` lines. The first run warmed caches the second reused, so the 20% compares the summary calls with their own run, not the two runs with each other. Interactive sessions add the title call and arm summaries without the variable; I did not measure them.

## Key numbers

- **0** model tokens for the Claude Code status line script ([statusline docs](https://code.claude.com/docs/en/statusline) , read**1 November 2026** ).
- **16.4%** of one organisation's weekly Claude Code spend went to`agent_summary` (Flamerix AI, gist of**28 October 2026** ).
- **~2%** of cost and under**4%** of requests across Anthropic's telemetry users,**~6%** in the terminal (Anthropic,**29 October 2026** ).
- **8% to 26%** of spend or tokens in user measurements of subagent-heavy sessions,**August to October 2026** .
- **30 seconds** between summary calls per working background agent, unchanged in**2.1.316** .
- **43,394** context tokens in a one-word reply with my full setup,**16,222** in safe mode and**2,102** with no tools (my runs,**1 November 2026** ).
- **8.5%** measured output saving from Caveman against**65%** advertised (JetBrains,**July 2026** ).

## New posts by email

About one email a week with what we published. No account needed.

## Which of these do you use?

Nobody on Stackness runs ccusage yet. Tick what you use and be the first.

[Play Lonny Eagle Amateur Skater 4A pixel art skateboarding game. Signing up opens it straight away.Sign up to play](https://stackness.dev/games/lonny-eagle)