PostgreSQL's MCP server costs 35 tokens to sit in your context. Freee's costs 17,500. Same protocol, same JSON, 500x apart before the agent has said a single word.
I ran the same session boot against four production MCP servers — PostgreSQL, Google Maps, GitHub, and Freee — and priced the tool definitions at Claude 3.5 Sonnet input rates. The bill for "just being connected" is small on any single call. It's not small when you multiply it by a year of daily runs, and it's not small when you find out most of the tokens are for tools you will never invoke.
Here is the audit.
Why "connect" costs tokens at all
The first thing a Model Context Protocol client does after handshaking is call tools/list. The server responds with every tool it exposes: name, description, JSON Schema for parameters, and any annotations. Every one of those bytes lands in the LLM's context window before the user has typed a prompt.
Old-style REST integration didn't work this way. You called the one endpoint you needed. If Stripe added forty new endpoints last quarter, your app didn't get slower or more expensive.
MCP inverts that. Connect a server that ships 270 tools and you get all 270 tool definitions, permanently, for every session. The library metaphor is the honest one: you asked to borrow a single book, and the librarian handed you the entire catalog first.
The four-server audit
I measured each server's tools/list response with tiktoken (Claude uses the same tokenizer family for cost purposes) and priced it at $3 per 1M input tokens.
| MCP server | Tools shipped | Boot-time tokens | Cost per 10 sessions |
|---|---|---|---|
| PostgreSQL (official) | 1 | ~35 | ~$0.001 |
| Google Maps | 7 | ~704 | ~$0.02 |
| GitHub (official) | 26 | ~4,242 | ~$0.13 |
| Freee | 270 | ~17,500 | ~$0.52 |
Two things fall out of that table.
First, the range is not linear. Going from PostgreSQL to Freee is 500x on the token axis, not 270x on the tool axis, because Freee's descriptions are longer and its schemas are richer. A single Freee tool costs roughly 65 tokens of definition, versus roughly 35 for a stripped-down PostgreSQL one.
Second, GitHub is the interesting middle case. The official server ships 26 tools if you take the vanilla bundle, but I've seen forks and community rewrites push that to 90+ tools with correspondingly larger token bills. The InfoQ writeup from May 2026 clocked one large-team configuration at 55,000 tokens of boot-time overhead — roughly 21% of a 200K context window, paid before the first prompt. That's the same shape as Freee, just wearing a hoodie.
The number to fear is not "how many MCP servers do I have." It's "how many tool definitions am I loading, and how verbose are they."
Why Freee balloons to 270 tools
Freee is a Japanese SaaS platform that bundles five back-office APIs — accounting, HR, invoicing, timekeeping, and sales — under one login. The MCP server mirrors that structure honestly:
| Freee API | Purpose | Approximate tools |
|---|---|---|
| Accounting | Deals, ledger, trial balance | ~80 |
| HR | Employees, departments, payroll | ~60 |
| Invoicing | Draft, send, reconcile | ~40 |
| Timekeeping | Punch, overtime, leave | ~50 |
| Sales | Quote, order, revenue | ~40 |
If you're a small business using every corner of Freee, this design is exactly right. You want the accounting agent to reach into invoicing without a second server handshake.
If you're an individual filing one annual tax return, ten of those 270 tools would cover you, and the other 260 are dead weight in your context window for the entire session.
Nobody at Freee did anything wrong. Their MCP server matches their product surface area. What went wrong is the assumption that "connect a server" and "load its tools" should be the same action.
The yearly cost, spelled out
Filing a Japanese sole-proprietor tax return realistically involves 10-ish sessions per month with the accounting API. At 17,500 tokens per session boot, at $3 per 1M input tokens:
Per session: 17,500 × $3/1M = $0.0525
Monthly: 10 × $0.0525 = $0.525
Yearly: 12 × $0.525 = $6.30
Six dollars is not going to bankrupt anyone. Two things about that number still deserve attention.
One: that's just the definitions. Actual tool calls, arguments, and results are billed separately. The $6 is what you pay for the librarian handing you the catalog, before you've read a single page.
Two: this scales with usage, not with the tools you actually use. A daily user of the same MCP config pays ~$20/year. A team of ten pays $200. A middleware layer running this in every automation run pays real money.
Compare to Freee's own subscription (¥2,380/month ≈ $200/year). The MCP overhead is small next to the product. It's not small next to "we're paying for a bill line no one on the team knows exists."
Three ways to shrink the bill
Strategy 1: allowlist the tools you actually use
The single biggest lever. Most MCP clients let you filter which tools get exposed from a server. Configure it once and 96% of Freee's boot cost evaporates:
{
"mcpServers": {
"freee": {
"allowedTools": [
"create_deal",
"list_deals",
"get_deal",
"update_deal",
"get_trial_balance",
"list_account_items",
"list_partners",
"list_taxes",
"list_walletables",
"get_company"
]
}
}
}
Ten tools, ~650 tokens. That's a 96% cut from the 17,500 baseline, and the agent still gets everything a tax return needs. This is the change GitHub itself credited in the May 2026 InfoQ piece for a 62% drop in agent workflow token spend — the mechanism was audits and pruning, nothing exotic.
Strategy 2: rewrite the descriptions
MCP tool descriptions are English prose, and English prose has a wide dynamic range on token count. The same tool, honestly documented, can cost 80 tokens or 20:
// ~80 tokens
{
"description": "Uses the freee accounting API to create a new transaction (journal entry) against the specified company_id. Accepts amount, date, account item, partner name, and memo. Consumption tax classification is inferred automatically from the account item."
}
// ~20 tokens
{
"description": "Create a transaction. Args: amount, date, account_item, partner."
}
The verbose version reads like docs. The terse version reads like a signature. Agents infer the same behavior from both — the schema already spells out the parameter names and types — and you save 60 tokens per tool. Multiply by 270 tools and it's non-trivial.
If you're building an MCP server, this is the highest-leverage habit to form early. Descriptions written like API reference docs cost more than descriptions written like function signatures, and both get you to the same agent behavior.
Strategy 3: connect on demand, not on boot
The token bill is per session, so a long-running interactive session with Freee always attached pays it once. A batch job that spawns 100 sessions pays it 100 times.
If a task only needs Freee for one step, connect for that step and disconnect. Most modern MCP clients — including Claude Desktop, Cursor, and Codex CLI — let you enable and disable servers per session or per project. Keep the giant servers off by default. Bring them in when the task actually requires them.
What to evaluate before adopting a new MCP server
The community has spent 2026 auditing servers rather than adding them — see the getunblocked, PolicyLayer, and mcp-audit tooling that emerged this spring — and the useful checklist has settled around four questions:
| Question | Good signal | Bad signal |
|---|---|---|
| How many tools ship by default? | Under 20, purpose-scoped | Hundreds, bundled by product surface |
| How long are the descriptions? | Function-signature length | Paragraph, marketing-inflected |
| Can I filter tools client-side? |
allowedTools or equivalent |
All-or-nothing connection |
| Does the vendor publish boot-time token counts? | Yes, in the README | You have to measure it yourself |
Servers built by teams that have felt the token bill answer these questions on the tin. Servers built without that pressure make you find out at runtime.
The bigger frame
MCP was designed for composability, and composability has a cost the original design didn't foreground. Every server you connect is a permanent tax on the model's attention and your input token budget, whether you use its tools or not. The ecosystem is still catching up to that reality — 14,000+ servers as of May 2026, and the audit tooling is barely older than that.
The good news is that the fixes are cheap and mostly local: allowlist the tools you use, keep descriptions tight, connect on demand. The bad news is that most teams find this out the same way I did — by running the numbers on the bill they were already paying, and being unpleasantly surprised.
If you've never audited yours, the ten minutes it takes to enumerate what your MCP setup is loading is the highest-ROI ten minutes you can spend on your agent this quarter.
The full version of this — the four-server measurement methodology, the yearly cost model at each Claude tier, and eleven MCP servers audited end-to-end — is what my book on MCP security practice covers.
MCP Security Practice: Auditing Tools, Tokens, and Trust in the Model Context Protocol
Sources: InfoQ — GitHub Slashes Agent Workflow Token Spend up to 62%, getunblocked — MCP Token Cost: A Line-Item Autopsy, PolicyLayer — MCP Token Cost Calculator, mcp-audit on GitHub.
Top comments (0)