Claude Code: 86% of token costs hide in invisible overhead, not your prompts

Claude Code burns far more tokens than developers realize, and the Anthropic billing interface doesn't explain where they go. A detailed trace of real usage across a 45-person engineering team over 30 days revealed the breakdown: only 14% of input tokens came from user prompts. The remaining 86% was context that the developer never explicitly shared. Prior assistant context alone—the conversation history and tool outputs replayed on every turn—consumed 30–45% of total input spend. Tool-related tokens (file reads, bash commands, and tool call overhead) made up 23% of input spend and 24% of output spend combined. MCP server schemas added up to 16,000 tokens per turn for a developer with 10 connected servers. Thinking tokens, which Claude uses for internal reasoning, could consume up to 40% of output spend at enterprise scale, though Anthropic later reduced the default thinking effort from "high" to "medium" after finding it cut output tokens by 76% with the same task completion rate.

The scale of this problem is already visible across the industry. Uber deployed Claude Code to roughly 5,000 engineers and watched per-person monthly bills climb to $500–$2,000. Another report described a single developer on a $200 Max plan consuming $50,000 worth of tokens in one month just by using the features as offered. Claude Code has already crossed $1 billion in annualized revenue. Yet the visibility into what drives those costs is almost nonexistent. The Anthropic Console shows organization-level token totals over time but not category breakdowns. The /cost command shows session-level aggregates but not what portion came from tool replays or MCP schemas. The /context command shows current window usage but does not track patterns over time or compare configurations across developers. For an org with dozens or hundreds of developers, each with their own MCP servers, skills files, and system prompts, manual auditing breaks down; configurations drift, and nobody removes anything because nobody knows what's safe to remove.

Comet addresses this gap with Cost Intelligence, a feature integrated into Opik (their observability platform). The tool works by running a proxy plugin that intercepts API traffic between Claude Code and the Anthropic API, hashes content for privacy, extracts structural metadata like category and character count, and sends cost metrics to Opik. No SDK integration or code changes are required; data appears after the first traced session. The setup is a single config block in the Claude Code settings file. Once connected, the Home dashboard displays a Sankey diagram mapping every token from its source category (prior assistant context, tool results, thinking, MCP schemas, static overhead) through the coding agent to its output category. Clicking into any category shows the cost split—for example, prior assistant context breaks down to 64.5% from replayed tool_use, 35.4% from text, and 0.1% from thinking. Clicking on MCP Servers displays a ranked per-server view showing total spend, call volume, and a "Waste" metric that flags servers with zero calls still loading their schemas on every turn. The User Leaderboard shows per-developer spend alongside model choice, token consumption, skills count, MCP count, and call volume, with a "High spend" flag marking outliers.

The feature that separates Cost Intelligence from a simple dashboard is the cost savings engine. The Cost Savings page surfaces specific recommendations ranked by estimated savings, each with an explanation and a quality impact warning. Switch default model to Sonnet (costs 0.6× Opus per tier, handles the same tier-weighted development work, estimated savings 22–48%). Compact context sooner (lower auto-compaction threshold to trim context prefix before each replay, estimated 10–15% savings). Lower thinking effort (disable always-on thinking and cap thinking tokens, estimated 6–7% savings). Block specific MCP servers (Cost Intelligence identifies servers with high inactive user counts and zero-call installs, calculating recoverable spend per server). Cap output tokens (prevent long generations from running away on cost by bounding maximum response length). Disable auto memory (remove recurring overhead while keeping project CLAUDE.md and rules). Drop git instructions (remove workflow instructions from the system prompt if teams don't rely on them). Each recommendation includes an "Apply" button that implements the change directly; for org-wide deployment, a settings export generates a managed-settings.json file that enforces all enabled policies across the team. Comet's own engineering team applied this exercise to their Claude Code usage before building it into a product. After refactoring their configuration—centralizing rules, migrating always-on skills to on-demand, adopting short session loops—their median output cost dropped from $229 to $181 per million output tokens, a 21% reduction with zero change in development velocity.