When a developer eagerly opens a terminal, before typing a single command, the AI coding assistant has already “eaten” through tens of thousands of tokens in the background. This startling reality has surfaced through new benchmark data from AI consultancy Systima.

Systima’s tests show that Anthropic’s flagship coding tool, Claude Code, sends approximately 32,800 tokens to the large language model before receiving any meaningful user input—consumed entirely by system prompts and tool descriptions. By comparison, open-source rival OpenCode requires just 6,900 tokens for its initial load, meaning Claude Code’s “idle cost” runs 4.7 times higher. When standard MCP servers, configuration files, and plugins are mounted, that figure can surge to 75,000 tokens.

The data exposes a long-overlooked hidden cost in AI coding: the more powerful the tool, the heavier its behind-the-scenes operations may be.

The Invisible Token Burn: From 33,000 to 75,000

To quantify the hidden overhead of AI coding tools, Systima designed a rigorous controlled experiment. Using the same computer and the same underlying model—Claude Sonnet 4.5—they set up a relay server to intercept and tally the data packets that Claude Code 2.1.207 and OpenCode 1.17.18 sent to the model before any interaction.

In a clean environment, when given the minimal instruction “just reply OK,” Claude Code’s first request payload reached 32,800 tokens. Systima’s breakdown revealed that beyond the system prompt, Claude Code embeds descriptions for as many as 27 tools, with those descriptions alone accounting for roughly 24,000 tokens. In contrast, OpenCode ships with just 10 built-in tools, keeping its initial request to 6,900 tokens. Even when all tools were disabled on both sides, Claude Code’s system prompt still weighed in at 6,500 tokens—more than triple OpenCode’s.

This 33,000-token initial payload not only means a higher bill but directly eats into the model’s “thinking space.” Systima noted that with a 200,000-token context window, Claude Code consumes 16% of capacity before reading any code or engaging in conversation. As dialogue deepens, the system must perform summary compression, further driving up token consumption.

In real-world development scenarios, the situation is even more severe. Systima simulated an environment loading a 72KB project rules file (CLAUDE.md) and connecting to MCP servers. The data showed that the rules file alone adds roughly 20,000 tokens to every request. As for MCP servers, each small-scale instance connected adds 1,000 to 1,400 tokens to the initial payload—connecting five of them devours an additional 5,000 to 7,000 tokens.

When Systima configured Claude Code into a “practical form” with instruction files, MCP, and plugins, the amount of data sent to the model before the user uttered a word reached a staggering 75,000 tokens, with the tool count swelling to 118 and total data size hitting 311KB. Systima estimates that, depending on configuration, the initial payload typically ranges between 75,000 and 85,000 tokens.

Not Always Waste: The Efficiency Paradox Under Heavy Load

Despite the massive initial overhead, Systima’s testing revealed a counterintuitive conclusion: the tool that “burns more money” at the start does not necessarily have the highest total consumption.

In a chained test involving file creation and program execution, Claude Code leveraged its powerful parallel tool-calling capability to complete the task in just three requests, with total input tokens reaching 121,000. OpenCode, by contrast, tended to call tools one at a time in a single-threaded fashion, requiring nine requests to finish—pushing its total input tokens to 132,000, surpassing Claude Code. Systima’s analysis suggests that while lightweight tools have lower per-request consumption, frequent interactions cause repeated context retransmission, and the long-tail effect can erase the gap.

However, Claude Code’s “sub-agent” feature is a genuine token black hole. Tests showed that when a task was delegated to two sub-agents running in parallel, total input tokens exploded from 121,000 for direct processing to 513,000—because each sub-agent must load independent prompts and tool descriptions, and the parent agent must read results a second time.

Getting “Dumber” or “Lazier”? Re-examining the Effort Mechanism

Claude Code’s high token consumption also ties closely to Anthropic’s recently clarified “Effort” mechanism. The internet had previously erupted with collective complaints that Claude Code was “getting dumber.” AMD’s AI head Stella Laurenzo even analyzed 6,852 session logs and pointed out that Claude’s reasoning volume had once plummeted by 67%.

According to a report citing Anthropic’s official blog, the root cause was not model degradation. Rather, on March 4, Anthropic had quietly lowered Claude Code’s default Effort setting from high to medium to reduce latency. It was not until April 7 that the company restored the default to high.

Anthropic offered a clear distinction: model selection determines “whether it can”—the knowledge boundary frozen into the weights—while Effort determines “whether it’s willing to try”—the degree of investment in reading files, running tests, and multi-step reasoning. Official data shows that for the same prompt, high Effort can generate seven times the tokens of low Effort, with the extra tokens all spent on verification and confirmation. This means a mid-tier model like Sonnet paired with high Effort can absolutely outperform a top-tier model running on low Effort in engineering deployments.

How Developers Can Respond

Systima’s report recommends that AI agent operators should not just look at the final bill but should deeply log the actual data volume received by the model. Incrementally adding instruction files and MCP servers while monitoring load changes is the only path to cost optimization.

Meanwhile, Anthropic is also easing context pressure through progressive disclosure mechanisms. For example, Claude Code’s Skills feature loads specific content only when each Skill is activated, and the total manifest length is hard-capped at 1% of the context window, curbing unchecked token consumption growth.

For developers, while marveling at AI coding efficiency, it may be time to start managing every token’s journey with the same rigor as an engineering budget.