When you connect an AI agent to a Model Context Protocol server, you're not just enabling tools—you're signing up for a silent token extraction that compounds with every conversation turn. A developer going by mrclaw207 ran the numbers after noticing their daily token counts spiking without proportional work output, and what they found should alarm anyone running MCP in production.

The Numbers Don't Lie

The culprit isn't model reasoning—it's context overhead from MCP tool definitions stuffed into the system prompt. Benchmarks comparing identical 10-turn conversations with a Claude Code agent show the damage: zero MCP servers consumed 2,400 tokens per turn (240,000 daily). Adding three servers ballooned that to 18,700 tokens per turn. Five servers hit 31,200 tokens per conversation turn. That's not incremental—it's an order of magnitude.

The Compounding Problem

The raw token count understates the hemorrhage in two critical ways. First, when 30–40% of your context window is MCP tool schemas, the model has less room for actual conversation history and task context. Longer conversations degrade faster, with agents suddenly "forgetting" things they knew just three turns ago—not a memory issue, but an occupancy problem. Second, system prompts don't benefit from the compression techniques that work on user messages. You're paying full price every turn, indefinitely. The MCP ecosystem report from May 2026 confirms this is systemic: over 13,000 MCP servers now exist, and the average developer connects four to seven of them to their agent. The context tax isn't an edge case—it's the default operating condition for most production deployments.

Three Fixes That Actually Work

Testing revealed most recommended solutions fall short. Here's what moves the needle:

On-Demand Tool Loading via MCP Gateway

Instead of loading all tool definitions upfront, route calls through a gateway that injects only currently relevant schemas. The model requests a tool category, and only then does the gateway add that server's schema to context—dropping overhead from roughly 8,000 tokens per call to around 400. The MCP Guild's gateway spec v0.3 (May 2026) supports this natively.

Semantic Tool Routing with a Cheap Classifier

Before sending requests to any MCP server, run a lightweight intent classifier that routes to only the most relevant server—a separate, cheap model call costing roughly $0.0001 per request. For teams running 100 conversations daily, this cuts MCP overhead by 60–80% and saves approximately $1,500 monthly against a $30/month classifier bill.

Tool Schema Compression

MCP's verbose JSON schema format prioritizes correctness over efficiency. Strip descriptions to essential nouns, remove examples fields, and abbreviate parameter names. A 400-token tool schema compresses to roughly 120 tokens with identical behavior—the model doesn't need verbose prose to call a read_file tool correctly.

The Bottom Line

If you're running production agents with five or more MCP servers and haven't measured your per-turn token overhead, you're probably hemorrhaging 30–40% of your API bill on context that adds zero reasoning value. Stop treating this as an acceptable cost of doing business—context budget is infrastructure, and it's time to audit it like one.