Chapter 54·Intermediate·9 min read
Model Context Protocol (MCP): A Standard for Agent Tools
What is MCP? A plain-English guide to the Model Context Protocol — how it gives AI agents a standard way to connect to tools, data, and services, why it exists, and how clients and servers fit together.
June 30, 2026
In the tool-calling chapter we said tools are how an agent acts. But there was a hidden problem we skipped: connecting an agent to each tool used to be bespoke, hand-written glue. The Model Context Protocol (MCP) is the attempt to standardize that connection — and it's worth understanding because it's quickly becoming how agents and tools meet.
The integration mess MCP solves
Suppose you have a few agent applications and a pile of things they should connect to — a database, GitHub, your file system, an internal API. Without a standard, every pairing is custom code:
This doesn't scale. Each integration speaks its own dialect, breaks on its own schedule, and has to be rebuilt for the next agent. The ecosystem needed a common language.
What MCP actually is
MCP is an open protocol that standardizes how an AI application connects to tools and data sources. Instead of custom glue per pairing, a tool is wrapped once as an MCP server, and any MCP client (an agent app that speaks the protocol) can discover and use it.
The common analogy is USB-C for AI. Before USB-C, every device had its own connector. After it, one port fits everything. MCP aims to be that universal port between agents and the tools they use.
The payoff is arithmetic: the N-times-M integration problem becomes N-plus-M. Build M tools as MCP servers and N agents as MCP clients, and every agent can use every tool — no per-pair glue.
Clients and servers
MCP has two roles, and the naming trips people up at first:
| Role | Who plays it | What it does |
|---|---|---|
| MCP client | The agent application | Discovers available tools and calls them |
| MCP server | A wrapper around a tool/data source | Exposes tools, data, and prompt templates |
A single agent app (the client) can connect to many servers at once — a filesystem server, a GitHub server, a database server — and use all their tools through the same protocol. Note that "server" here doesn't have to mean a remote machine; an MCP server can run locally right next to your agent.
What does a server expose? Three things: tools (actions the agent can take), resources (data the agent can read), and prompts (reusable templates). For our purposes the headline is the tools — they're exactly the function calls from the previous chapter, just offered through a standard interface.
What MCP is not
It's easy to over-mystify a new acronym, so let's be precise about the boundaries:
- MCP does not make a model smarter, plan better, or remember more. Everything from the earlier chapters still applies unchanged.
- MCP does not decide which tool to call — that's still the model's job, using the tool schemas it's shown.
- MCP does standardize the wiring: how tools are described, discovered, and invoked.
In other words, MCP is plumbing. Underneath, an MCP tool call is the same call-and-observe loop from the tool-calling chapter; MCP just defines the shape of the pipe so the same tool works across every compliant agent.
Why it matters for you
Even if you never implement the protocol yourself, MCP changes the landscape in a practical way: tool integrations become reusable assets instead of one-off code. A growing library of ready-made MCP servers means an agent can gain a new capability by connecting to an existing server rather than someone writing fresh glue.
And the same validation lesson from before still holds — arguably more so. A standard that makes it easy to plug in many tools also makes it easy to over-arm an agent. The protocol handles the connection; you still decide which tools an agent is allowed to reach and guard the dangerous ones.
Recap
- Before MCP, every agent-to-tool connection was bespoke glue — an N-times-M problem that didn't scale.
- MCP is an open protocol that standardizes how an AI app connects to tools and data — "USB-C for AI."
- The client is the agent app; servers wrap tools, data, and prompts. One client can use many servers.
- It turns integration into an N-plus-M problem: build a tool once, use it from any MCP-aware agent.
- MCP is plumbing — it standardizes the connection, not the model's intelligence or its tool choices.
We've covered every piece: the loop, planning, memory, tools, teams, and connectivity. The last question is practical — do you build all this by hand? That's where agent frameworks come in. Continue to AI Agent Frameworks.