MCP Is a Plug, Not a Brain: Where the Protocol Ends and the Agent Loop Begins
Tool calling, the wiring problem MCP solves, its roles and transports, how it differs from orchestration, a minimal FastMCP server, and when to skip it.
This article is published in English.
Sources: MCP Is a Plug, Not a Brain
Ask ten people what MCP is and a good share will say it is how agents get built. It isn't. MCP is a plug: useful, well designed, increasingly universal, and still only a plug. Getting that straight clears up a lot of muddled thinking about agentic systems.
Start one level down: tool calling
A language model produces text, and that is all it does. It can't query a database, open a file or call an API. What it can do, once it has been told which tools exist and which arguments they accept, is emit a structured request in place of an answer. Faced with a question about a failing sync, it won't guess. It outputs something like a call to search_runbooks with the query ERR_4412. Application code spots that request, runs the real function and returns the output as the next message. The model reads the result and either replies or asks for another tool.
Keep the division of labor in mind, because everything later depends on it. The model decides to call a tool. The code executes the call. The model never runs anything itself. Every agent, every framework and every so-called autonomous system is this round trip repeated in a loop.
The problem MCP addresses
Tool calling already worked in 2024. The pain was wiring. Each host application described tools in its own way. Making a team's runbook search available in Claude Desktop took one integration, Cursor took another, and a custom agent took a third, each with its own schema format, argument passing and result handling. Five hosts and six tools add up to thirty integrations, all slightly different and all aging on separate schedules.
The situation resembles USB or JDBC: agree on the plug and the combinations stop multiplying. The Model Context Protocol, released by Anthropic in late 2024 and now maintained under the Linux Foundation, standardizes the connection. Whoever provides a tool writes a single MCP server, which lists the tools in one agreed format and responds to calls through one agreed wire protocol. Every MCP host can then discover and use those tools with no custom code. Five hosts and six tools become eleven pieces, not thirty.
Underneath sits JSON-RPC, a request and response format roughly fifteen years older than MCP. Nothing in the protocol is exotic. Its value comes entirely from everyone agreeing to use it.
The parts, precisely
Three roles. The host owns the model and the conversation: Claude Desktop, Cursor or a custom agent. Inside it, one client per server manages the connection. The server exposes the tools. Put simply, the host runs the model and the loop, the server holds the tools, and each client is the link joining the two.
What a server can offer. There are three kinds. Tools are functions the model invokes. Resources are data the host reads into context, such as a file or record. Prompts are reusable templates a user can choose. Most real use involves tools.
Two transports. With stdio, the server runs as a local subprocess and communicates over standard input and output, which is how Claude Desktop starts servers on a laptop. Streamable HTTP serves remote deployments.
A recent change. The July 2026 revision made MCP stateless at the protocol level. No handshake opens a session and no session id needs carrying, since each request stands alone. In practice a remote MCP server is now simply an HTTP service that can sit behind an ordinary load balancer and scale like any other. Material describing MCP sessions and initialize calls covers the previous version, which still works under a twelve-month deprecation window but isn't where things are headed.
Where MCP sits relative to orchestration
Think of an agentic system as four layers.
- Layer 1, the model. It reasons over the conversation and picks the next tool.
- Layer 2, the tools. Functions that do the actual work.
- Layer 3, the protocol. MCP. It covers tool discovery by the host and the route a call takes to the tool and its answer back.
- Layer 4, the loop. Orchestration. This code sends a message, spots a tool request, executes it, passes the result back and chooses between another round and stopping. If an "agent" exists anywhere, it exists here.
MCP occupies layer three and orchestration occupies layer four, and neither replaces the other. Asking how they differ is like asking how HTTP differs from a microservice architecture, since one is a wire format and the other is control flow. A perfectly good agent can exist without MCP, with functions wired in directly, which is how nearly everyone did it in 2024 and how many still do. The reverse doesn't hold, because an MCP server idles until some loop calls it.
So a question such as "MCP or LangGraph?" contains a category error. LangGraph runs layer four, while MCP is one choice for layer three. A project may use both, either or neither.
What MCP does buy is portability. Build a runbook server once and the on-call engineer reaches it from Claude Desktop, the platform team's triage agent reaches it from LangGraph, and a developer reaches it from Cursor in the middle of a debugging session. One server serves three hosts and nothing gets built twice. That is a real benefit, though it concerns plumbing, not intelligence.
What a server looks like
A complete server exposing runbook search takes very little code. This one uses FastMCP, the library most Python servers are written with.
from fastmcp import FastMCP
mcp = FastMCP("logistics-runbooks")@mcp.tool
def search_runbooks(query: str, limit: int = 5) -> list[dict]:
"""Search internal runbooks and release notes.
Use for error codes, service names, or incident symptoms."""
results = runbook_index.search(query, top_k=limit)
return [
{"id": r.id, "title": r.title, "excerpt": r.excerpt, "url": r.url}
for r in results
]if __name__ == "__main__":
mcp.run()
That is the entire thing. The decorator derives the protocol's required JSON Schema from the function's type hints, and the docstring becomes the text a model consults when judging if a tool fits. mcp.run() starts the server on stdio so Claude Desktop can launch it as a subprocess, and moving to HTTP for a remote deployment takes a single argument.
Two details deserve attention. The docstring does real work, as it is the only thing the model sees when choosing among tools, so it should be written for the model rather than for colleagues. And runbook_index.search is ordinary retrieval code, the kind of hybrid search with a reranker used in RAG systems. MCP didn't make it smarter. It made it reachable.
Why the confusion persists
Three things feed it.
The name. "Model Context Protocol" sounds like it describes how models think, when it describes how they connect to things.
The demos. Most MCP demonstrations show Claude Desktop doing something impressive through a server, which reads as MCP making Claude do it. In fact Claude Desktop's built-in loop did that. MCP only explains why the tool was available.
The timing. MCP appeared just as agents became everyone's project, so it was filed under agent technology. Integration technology is the better shelf, alongside REST and message queues. Agents use it, but it was never about agents.
When to bother
Reach for MCP when one tool must serve more than one host, or when consuming tools others already built. Thousands exist now, covering most systems anyone would want to reach, and in both cases MCP removes real work.
Skip it when a single agent calls a handful of private functions that nothing else will need. Wire them in directly. If circumstances change, wrapping them in a server takes an afternoon, and the choice will be a clean one because the added piece is fully understood.