MCP: a standard way to give agents tool access and context
MCP (Model Context Protocol) is a standard for connecting models and agents to external tools, data, and context in a structured way. This page explains what MCP is, why it matters for the tool and knowledge layer, and where it fits in an agentic stack.
What is MCP?
MCP is a protocol/standard for connecting models and agents to external tools, data sources, and context in a structured way, instead of each integration being a one-off. In an agentic stack, MCP is one way to give the agent a clean interface to the tools and knowledge it needs — and to keep that interface standardized rather than bespoke.
Why MCP matters for agents
Agents need to use tools and access context. MCP is one standard way to do that.
An agent that can only generate text is limited. To act, it needs to call tools, read data, write back, and often interact with external systems. Without a standard, each of those integrations tends to become a custom plugin, a custom prompt convention, or a custom client–server setup. MCP is an attempt to make that cleaner and more standard.
From the knowledge perspective, MCP matters because it is one of the places where the knowledge layer meets the action layer. The tools an agent uses, the context it reads, and the knowledge it acts on all have to be connected somehow. MCP is one standard for that connection.
MCP and the knowledge layer
MCP is not itself the knowledge layer. It is a transport/interface layer: it is one way to expose tools and context to a model or agent. The knowledge layer is what says what is true, current, owned, and allowed. MCP can carry that knowledge to the agent, but it does not replace the knowledge layer.
The useful way to think about it:
- Knowledge layer. What the agent should know: facts, procedures, state, permissions, freshness, scope.
- Context engineering. How that knowledge is delivered to the agent for a given task.
- MCP. One standard interface for exposing tools and context so the agent can use them.
A good system uses all three: a real knowledge layer, a real context design, and a standard interface like MCP to connect them to the agent.
Where MCP fits in the stack
In the agents stack on this site, MCP sits alongside LLMs, tool use, and computer use:
- LLMs — the reasoning core.
- Agents — the loop that reasons, acts, and continues.
- MCP — one standard interface for tools and context.
- Tool use — the action layer, the actual things the agent does.
- Computer use — acting at the UI/computer level when needed.
MCP is valuable because it can reduce bespoke integration work and make tool/context access more standard. It is not a substitute for good knowledge, good context, or good guardrails.
Where to go next
- Agents — the capability layer.
- LLMs — the reasoning core.
- Tool use — the action layer.
- Computer use — UI-level action.
- Knowledge Lifecycle — the knowledge layer behind it.
- Contact
Sources and further reading
- Model Context Protocol (MCP) — see the official MCP documentation and announcements from the standard's maintainer for current specification and usage.
- Retrieval-Augmented Generation for Large Language Models: A Survey — arxiv.org/abs/2312.10997