pip install mcptoon



# 30-second proof, on your machine — none of your servers, no API key:

mcptoon demo --quick



# Add any MCP server — one command:

mcptoon add everything --stdio npx -y @modelcontextprotocol/server-everything



# What your agent actually reads (names only — 581 tokens, not 71,929):

mcptoon manifest

Your tools stay yours. mcptoon bundles nothing — it's a remote control, not a runtime. The MCP servers you want, you install yourself, one command each (npm/pip/a URL). Delete mcptoon someday? Your MCP servers keep running on their own — not one goes missing.

Mcptoon is the native decoupling layer for MCP tools. It fixes the twin pain of MCP tool listings eating tokens and every AI agent re-configuring tools on its own. Zero config, out of the box: it auto-scans and unifies the MCP tools of every agent on this machine — Claude Code, Cursor, Codex, scripts, CI — shares tool instances globally, and slashes token overhead.

This isn't just us talking

Those numbers are ours, but "loading every tool schema into context is expensive" is not a claim only we make:

• Anthropic: tool schemas flooding the context window is a real pain — one example drops from 150,000 tokens to 2,000 (a 98.7% saving)
• Firecrawl benchmark: the same task cost 1,365 tokens via CLI vs 44,026 via MCP — 32× (full schema loaded upfront)
• Scalekit benchmark: CLI is 10–32× cheaper and 100% reliable; MCP scores 72%
• MCP-Zero (arXiv:2506.01056): on-demand tool retrieval achieves near-constant cost regardless of tool count
• SEP-1576: an open MCP proposal to cut schema redundancy — the problem is acknowledged upstream

We're not the only ones who measured this. mcptoon is the one you can use today, covering every agent at once.

Up and running in 30 seconds

pip install mcptoon                          # pure stdlib, 128KB, zero dependencies



# Add any MCP server — one command:

mcptoon add everything --stdio npx -y @modelcontextprotocol/server-everything



# See every tool available (names-only by default; 255 tools cost 581 tokens):

mcptoon manifest



# Call a tool (JSON output by default; add --toon to save more):

mcptoon call everything echo '{"message":"hi"}'

What mcptoon demo actually prints

No API key, no MCP server of yours, nothing to configure: it boots the official "everything" reference server, calls one tool, and shows the token math on your screen. This is that output, verbatim from v0.7.11 (Windows, Python 3.12) — only the ASCII banner and the closing star-ask are cut:

$ mcptoon demo --quick



  Starting demo server...

  ✓ Demo server ready



  📊  SAME data, 19% fewer tokens:

              21  →          17   (SLIM)



  Format         Tokens    Savings

  ────────── ────────── ──────────

  JSON               21          -

  TOON               17        19%

  SLIM               17        19%



  Official benchmark: 255 tools, 50 servers, tiktoken cl100k_base:



  Format           Tokens    Savings

  ──────────── ────────── ──────────

  JSON             71,929          -

  TOON             47,438        34%

  SLIM              8,282      88.5%

  Compact             581      99.2%



  Now you can:

  ✓ connect every agent with ONE config   →  mcptoon sync

  ✓ expose ALL servers as ONE stdio server →  mcptoon serve

  ✓ never paste tool schemas again         →  mcptoon manifest --slim



  Schemas in context with mcptoon: 0 tokens (always)

Column padding follows your terminal width; the numbers do not. The first table is one live tool call measured on your machine; the second is the repo's committed 255-tool benchmark (docs/tiktoken-benchmarks.md), reproduced identically on every run.

Claude Code user? Skip the terminal entirely:

/plugin marketplace add activeing123/mcptoon

The plugin auto-installs the CLI (SessionStart hook), wires the mcptoon serve bridge via .mcp.json, and ships a skill that teaches the agent when to compress. /mcptoon-setup is the manual fallback.

Or let mcptoon auto-discover servers already on your machine:

mcptoon quickstart     # discover + configure + list tools — one command

That's it. No hand-written JSON config. No MCP protocol debugging. No polluted context window. The wheel is 128KB with zero dependencies, and mcptoon itself needs no API key and phones nothing home — $0 in service fees, everything runs on your machine.

The problem

Every MCP agent (Claude Code, Cursor, Codex, …) stuffs every tool's full schema into your context window before doing any work:

50 tools  → 14,113 tokens of schema → a 128K context: 11% gone

255 tools → 71,929 tokens of schema → a 128K context: 56% gone

So you unload servers you aren't using and reload them when you are. Back and forth. Adding one new server still means hand-writing a JSON config — one missing comma and everything breaks.

mcptoon fixes this. Your MCP servers stay configured, but their schemas never enter the agent's context by default. The agent just runs mcptoon commands, and only the compact result you asked for enters context — the name index weighs 581 tokens (114 for 50 tools, −99.2%).

Without mcptoon: 255 tools → 71,929 tokens, over half the window

With mcptoon:    255 tools → 581 tokens. 99.2% saved.

Both rows are measured configurations, not one number scaled up and down (tiktoken cl100k_base, assets/benchmark_tiktoken.json). Your mix will differ — compute your own numbers in the browser, 30 seconds, nothing uploaded.

The industry validated the problem — then gated the fix

Token-heavy tool context is no longer a niche complaint — it is now an official engineering problem, and the same answer keeps appearing on every roadmap:

• Anthropic: Tool Search Tool defers tool definitions until needed; Programmatic Tool Calling moves orchestration into code. Both are Claude-platform betas.
• MuleSoft: MCP Payload Optimization productizes clean → distill → compress (its compression stage is TOON). Enterprise gateway only, MCP up to 2025-06-18.

The direction is settled. mcptoon is the version of this answer you can run today, on every agent at once — the results-side discipline without the platform or gateway toll.

Installing MCP servers — one command each

# Install from npm (most MCP servers live here):

mcptoon install brave-search --npm @modelcontextprotocol/server-brave-search



# Install from pip:

mcptoon install my-tool --pip mcp-my-tool



# HTTP/SSE servers:

mcptoon install remote-api --url https://example.com/mcp



# List installed:

mcptoon install --list



# Uninstall:

mcptoon install --remove brave-search

mcptoon connects, discovers tools, generates the handler, registers it. No restart needed. Each install adds 0 KB to mcptoon itself — the CLI stays 128KB with zero dependencies, because servers are external processes your machine runs directly, not code bundled into mcptoon. Four steps, one command, no agent restart.