What MCP is
Before MCP, connecting an AI assistant to a database, a calendar or a code repository meant writing a custom integration for each assistant. The Model Context Protocol replaces that with one standard. Its documentation defines it as an open-source standard for connecting AI applications to external systems — data sources such as local files and databases, tools such as search engines and calculators, and workflows such as specialized prompts — and compares it to a USB-C port: one standardized connector instead of a different cable for every device.
Anthropic released MCP as an open-source project on November 25, 2024, describing it as a new standard for connecting AI assistants to the systems where data lives. It has since spread well beyond Anthropic: the protocol's site lists support in Claude, ChatGPT, Visual Studio Code, Cursor and many other clients.
How MCP works
MCP has two sides. An MCP server wraps a system — GitHub, a filesystem, a CRM, a browser — and exposes what it can do. An MCP client lives inside an AI application and connects to one or more servers. When the application calls a model, the client passes the servers' capabilities to it as tool definitions; when the model calls one of those tools, the client forwards the call to the right server and returns the result.
From the model's point of view nothing new happens: it sees tools, calls them and reads results, exactly as with any function calling. MCP standardizes the plumbing between the application and the systems, not the model's side of the conversation.
Inside the protocol
The architecture has three participants. The MCP host is the AI application — Claude Code, Claude Desktop, Visual Studio Code — and it creates one MCP client for each server it connects to, each client keeping a dedicated connection. An MCP server can run locally, typically over the stdio transport for a single client, or remotely over Streamable HTTP, which serves many clients and supports standard HTTP authentication; the documentation recommends OAuth for obtaining tokens. Messages follow JSON-RPC 2.0 either way.
Servers offer three kinds of things, which the protocol calls primitives: tools, executable functions such as file operations, API calls and database queries; resources, data that supplies context, such as file contents or database records; and prompts, reusable templates such as system prompts or few-shot examples. Clients discover each with a list request and invoke tools with tools/call. The host gathers the tools of every connected server into one registry the model can call — which is where the token cost below comes from.
The protocol is still moving. As of protocol version 2026-07-28 the sampling primitive, which let servers request completions from the client's model, is deprecated, and the documentation suggests that clients federating many servers use progressive tool discovery rather than loading every tool up front.
The token cost of connected tools
Because MCP tools reach the model as ordinary tool definitions, every connected server adds its tools' names, descriptions and schemas to the input of every model call — whether or not the model uses them. Connect a handful of servers with dozens of tools each and an agent can spend thousands of input tokens per request describing tools it never calls. Our journal calls this the MCP context tax.
The tax compounds in agents. An agent loop resends its full context on every step, so tool definitions are paid once per step, not once per task, and tool results — a fetched page, a query result — join the history and are paid again on every step after. Anthropic adds its own tool-use system prompt whenever tools are present, on top of the definitions themselves.
Worked exampleAn agent step with and without five MCP servers
50,000 requests a month on Claude Sonnet 5.5, priced at its current list rates, checked on 2026-10-09.
Fifty thousand agent steps a month. The 12,000 extra tokens stand in for the tool definitions of five connected servers — an assumption for illustration; measure your own with a token counter. The third column shows caching recovering most of the overhead when the tool list is stable.
Change the workload or the model in the LLM API cost calculator.
Reducing the context tax
- Connect per task, not per user. Load the servers a job needs rather than every server you have installed.
- Defer tool definitions. Anthropic's tool search tool lets the model search for tools and load only the definitions it needs, instead of receiving all of them up front.
- Cache the tool list. Tool definitions sit at the start of the prompt, so prompt caching can bill them at the read rate — provided the list stays identical between calls, since Anthropic invalidates the cache when a tool definition changes.
- Clear old results. Context editing removes stale tool results from long sessions.
A note on trust
An MCP server can read data and take actions with the permissions it is given, and its tool descriptions and results flow straight into the model's context. Treat a third-party server like any other dependency: install from sources you trust, give it the narrowest permissions that work, and review what its tools can do. The protocol's own documentation keeps a dedicated section on security best practices.