The Model Context Protocol (MCP) is an open standard for connecting AI agents to external tools and data sources. Instead of writing a custom integration for every capability, a developer runs or points to an MCP server, and any MCP-aware agent can discover and call what that server exposes through one consistent interface.
Why MCP matters
As agents took on real work, integrations became the bottleneck. Connecting a model to a ticketing system, a code repository, and a database meant writing three separate adapters, each tied to one framework’s tool format. Every new agent repeated that work, and a tool built for one system could not be reused by another.
MCP addresses this by standardizing the boundary between an agent and the outside world. A capability is implemented once, behind a server that speaks the protocol, and then any compliant client can use it. This decouples the people who build tools from the people who build agents, the same way a stable API decouples a service from its consumers — which is what lets a tool ecosystem grow independently of any single product.
How it works
MCP defines a client-server relationship between an agent and the systems it uses:
- An MCP server exposes a set of capabilities — tools to call, resources to read, and reusable prompts — described in a standard, machine-readable form.
- An agent acts as an MCP client and connects to one or more servers.
- On connection, the client discovers what each server offers, so the available tools are not hard-coded into the agent.
- When the model decides to act, the client sends a structured call to the server, the server executes it, and the result is returned to the model as context.
Because discovery and execution are standardized, the same server can serve many different agents, and an agent can mix capabilities from several servers without knowing how any of them are implemented internally.
MCP vs. function calling
The two are complementary rather than competing. Function calling is the model-level act of deciding to invoke a named function with arguments. MCP is the layer that makes those functions available in the first place — a standard way to advertise, locate, and run tools that live outside the agent. Function calling answers “which action and what arguments”; MCP answers “where do the actions come from and how do I reach them.”
In practice
A durable, observable runtime can connect to MCP servers and run their tools as server-side steps, so a model can call a remote capability without any custom worker code, and each call is persisted and traced like any other tool invocation. Calls to external servers can be wrapped in guardrails and surfaced in observability, and the model decides when to use them through ordinary tool use. This gives an AI agent a reusable catalog of capabilities without bespoke integration work. For configuration, see connecting MCP servers.