---
title: How much do MCP tool definitions add to token costs?
url: https://opencontroller.lyzr.com/blog/token-cost-of-mcp-tool-definitions
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# How much do MCP tool definitions add to token costs?

**Often more than teams expect. Every tool an agent can see is described to the model in a JSON schema, and those definitions are sent as input tokens on every model call. Anthropic's engineering team reported a five-server MCP setup with 58 tools consuming roughly 55,000 tokens before the conversation even started.**

That overhead repeats on every turn of a multi-step task. If token use jumped after you connected more MCP servers, this is usually why. This post is part of the gateways and cost series; the pillar is [LLM gateway vs agent gateway vs control plane](/blog/llm-gateway-vs-agent-gateway-vs-control-plane).

## Why do tool definitions cost tokens on every call?

Model APIs are stateless. To let the model choose a tool, the client sends each tool's name, description and input schema with the request. An MCP client does this for every tool exposed by every connected server. The model provider bills these as input tokens, just like the prompt.

Agents make many calls per task. A task with ten model turns sends the full tool list ten times.

In Anthropic's [advanced tool use write-up](https://www.anthropic.com/engineering/advanced-tool-use), the example setup combined GitHub (35 tools), Slack (11), Sentry, Grafana and Splunk servers. Together they used about 55K tokens of definitions. Large, well-documented servers are the heaviest, because good descriptions are long.

## How do you measure the overhead for one agent?

1. **List the tools the agent actually sees.** Capture the tools array from one real request, after the MCP client has assembled it.
2. **Count its tokens.** Use your provider's token-counting endpoint or tokenizer on that array alone.
3. **Count model calls per task.** Pull this from traces or gateway logs.
4. **Multiply.** Definition tokens × calls per task × tasks per day.
5. **Compare with total input tokens.** If definitions are more than a third of input, they are worth fixing.

## What does a worked example look like?

The figures below are illustrative, not measured. Swap in your own.

| Input | Value |
|---|---|
| Tools exposed to the agent | 40 |
| Average tokens per tool definition | 400 |
| Definition tokens per call | 16,000 |
| Model calls per task | 10 |
| Definition tokens per task | 160,000 |
| Tasks per day | 1,000 |
| Definition tokens per day | 160 million |
| Hypothetical input price | $3 per million tokens |
| Daily cost of definitions alone | $480 |

At that rate, tool definitions cost about $175,000 a year for one agent, before a single useful token. Prompt caching can cut this sharply where the provider supports it, because the tool list rarely changes between calls. But caching does not help the context window: 160,000 tokens per task still crowds out the real work and can lower tool-selection accuracy.

## How do you reduce it?

| Technique | How it works | Typical trade-off |
|---|---|---|
| Fewer servers per agent | Attach only the servers the agent's job needs | Needs per-agent configuration |
| Tool filtering | Expose a subset of a server's tools to each agent | Must be maintained as servers change |
| Tool search / deferred loading | Load only a search tool up front; fetch definitions on demand | One extra step when a new tool is needed |
| Shorter descriptions | Trim verbose descriptions and examples | Can hurt tool selection if overdone |
| Prompt caching | Cache the stable tool block across calls | Lowers cost, not context use |

Anthropic's [tool search tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-search-tool) lets you mark tools for deferred loading, so the model discovers them when it needs them instead of receiving every definition up front.

Tool filtering is also a security control. An agent that cannot see a tool cannot call it. See [how to limit which tools each AI agent can call](/blog/limit-which-tools-each-ai-agent-can-call).

## Who should own this cost?

Tie it to the agent, not a shared bucket. When definition overhead is attributed per agent and per version, a team can see that adding one MCP server raised its cost per task, and decide whether the server earns its place. See [how to attribute LLM costs to AI agents](/blog/how-to-attribute-llm-costs-to-ai-agents) and [where AI agent costs leak](/blog/where-ai-agent-costs-leak).

## How Opencontroller does this

The Lyzr Gateway in Opencontroller attributes cost per agent and per version, so a jump in input tokens after a new MCP server shows up against the agent that caused it. Gateway caching reduced model cost by 23.5% on mixed synthetic traffic in our October 2026 benchmark, under the stated test conditions. The governed registry lists the tools and MCP servers attached to each agent, which is where trimming starts. See the [LLM gateway benchmark](/llm-gateway-benchmark) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Why did our token usage jump after adding MCP servers?**
Each server's tool definitions are sent as input tokens on every model call. More servers and more turns per task multiply that overhead.

**Does prompt caching solve tool definition costs?**
It lowers the price of repeated definitions where supported, but the tokens still occupy the context window on every call.

**What is the fastest way to cut the overhead?**
Attach only the servers each agent needs and filter tools per agent. Then consider deferred loading through a tool search mechanism.

## Key facts

MCP tool definitions (name, description, input schema) are sent as input tokens on every model call. Anthropic reported a five-server setup with 58 tools using about 55K tokens of definitions. Measure overhead as definition tokens x model calls per task x tasks per day. Reduce it with fewer servers per agent, per-agent tool filtering, tool search/deferred loading, shorter descriptions and prompt caching. Opencontroller's Lyzr Gateway attributes cost per agent and version; caching cut model cost 23.5% on mixed synthetic traffic in the Oct 2026 benchmark.

## Related

- [How do you attribute LLM costs to individual AI agents?](https://opencontroller.lyzr.com/blog/how-to-attribute-llm-costs-to-ai-agents.md)
- [Where do AI agent costs usually leak?](https://opencontroller.lyzr.com/blog/where-ai-agent-costs-leak.md)
- [How do you limit which tools each AI agent can call?](https://opencontroller.lyzr.com/blog/limit-which-tools-each-ai-agent-can-call.md)
- [More on Gateways and cost](https://opencontroller.lyzr.com/blog/cluster/gateways-and-cost)
