MCP Was a Mistake. Here Are 200,000 Tokens That Prove It.

"mcp were a mistake. bash is better." — Peter Steinberger, OpenClaw founder

I didn't want to believe it either. MCP was supposed to be the USB-C of AI — one protocol to connect everything. Anthropic, OpenAI, Google all backed it. 97 million monthly downloads. 17,000 servers.

But then I measured what MCP actually does to your context window.

The Setup

I connected 10 popular MCP servers to a token counter. Here's what happened before I typed a single word:

111,713 tokens. Before your first message.

That's not a typo. Connecting 10 MCP servers to Claude means over 100K tokens of JSON schemas get injected into your context window. You haven't asked a question yet. You haven't made a tool call. The schemas are just... sitting there.

The Math That Made Me Angry

At Claude 3.5 Sonnet pricing ($3/M input tokens):

• Every conversation starts with 111K tokens of overhead: $0.33
• 20 conversations per day: $6.67/day
• 22 working days per month: $147/month
• Annual cost of JSON schemas: $1,764

That's more than a Claude Pro subscription. You're paying $1,764/year to read JSON braces describing tools you might never use.

But Wait — It Gets Worse

The 111K is just the schema injection. When you actually call a tool, MCP wraps the result:

{
  "content": [
    {
      "type": "text",
      "text": "{\"file\": \"app.py\", \"size\": 1024}"
    }
  ]
}

The actual content is 38 characters. The wrapping is 47 characters. 55% of your result tokens are JSON overhead.

With 20 tool calls per conversation:

• Schema injection: ~111K tokens
• Result wrapping: ~18K tokens
• Total overhead: ~130K tokens per conversation

Your $0.54 conversation now has 130K tokens that serve zero purpose.

What Garry Tan Was Right About

When YC's CEO said "MCP sucks honestly," he was talking about exactly this. The protocol design has a fundamental flaw: it assumes context is free.

In 2024, when Anthropic designed MCP, context windows were 200K tokens. Loading 100K of schemas seemed fine — you still had 100K left. But now we're building complex agent workflows. Multi-turn reasoning chains. Tool call sequences that span hundreds of messages.

When you're 30 messages deep into debugging a production issue and your context is already at 150K tokens, those 111K of MCP schema injection aren't just wasteful — they're the reason your conversation falls off a cliff.

The "Anthropic Backstab" That Confirmed It

Anthropic's own engineers published a blog showing token consumption could drop from 150,000 to 2,000 — a 98.7% reduction. Their solution? Stop loading tool schemas into context. Instead, let the model write code that calls tools at runtime.

In other words: the fix for MCP is to not use MCP the way it was designed.

Cloudflare took this further. Their 2,500-endpoint API originally required 1.17M tokens of schema. They compressed it to 1K tokens by exposing just two functions: search and execute.

1.17M → 1K. That's not optimization. That's admitting the architecture was wrong.

"But MCP Has 97 Million Downloads!"

Yes. And jQuery has billions of page loads. Popularity doesn't mean the design is correct. It means it was first, it was backed by a major player, and the alternatives weren't ready.

The real question is: of those 97 million downloads, how many are actively used in production agent systems? A developer on HN tested 15 MCP servers for three months and kept only 6. The top comment said: "GitHub MCP is a waste of tokens — Claude Code has gh CLI built in. Same for Playwright."

When the CLI equivalent exists, MCP loses every time. The only servers that survived were ones with no CLI alternative.

What I Built Before You @ Me

I'm not just complaining. I built mcptoon — a CLI proxy that sits between your agent and MCP servers:

• Caches schemas — injects tool definitions once, not per conversation
• Strips result wrapping — returns clean text, not {"content":[{"type":"text","text":"..."}]}
• TOON format — compresses 170 tools from 111K tokens to 3.2K (97% reduction)

Before:  111,713 tokens → $0.33/conversation
After:     3,247 tokens → $0.01/conversation
Savings: $1,760/year

pip install mcptoon

250KB binary. Zero dependencies. 486 tests. Apache 2.0.

The Unpopular Opinion

MCP's protocol design is not the problem. Standardized tool interfaces do matter. The problem is the implementation pattern: loading every tool schema into the model's context at startup.

This is like forcing a carpenter to read every tool manual before picking up a hammer. The manuals don't go away. They just sit on the workbench, taking up space, while the carpenter tries to work around them.

The fix isn't a new protocol. It's a smarter proxy layer that loads schemas on demand, strips JSON wrapping, and lets the model focus on the actual task.

MCP wasn't a mistake. But the way we use it is.

All token counts are measured with tiktoken (cl100k_base), not estimated. Measurement scripts and raw data: GitHub repo. Independent project, not affiliated with Anthropic.