Knowledge as a Model Context Protocol resource

What MCP is for

MCP is a way to give an agent a surface it can read — a server that says "here is knowledge, in this shape, with this basis, and here is how to ask for more." That is a useful thing, because the alternative is the bucket instinct — dump everything into the context and let the model sort it out. MCP is one disciplined answer to the question "how does the agent get the right knowledge at the right moment."

The knowledge layer is what makes that surface dependable. MCP is the exposure. The two are not the same, and the distinction matters: a knowledge server that exposes stale, unowned, ungrounded knowledge is a server that exposes the wrong thing in a disciplined way. The discipline is in the knowledge layer, not in the protocol.

Knowledge servers

A knowledge server is an MCP server that exposes knowledge as its primary resource — not as a general tool, but as knowledge the agent can read, query, and act on, with the basis attached. The server says what knowledge is available, in what shape, with what currentness, with what permission, and how to ask for more.

The knowledge server is the point where the knowledge layer meets the agent. It is where representation, lifecycle, grounding, and the agent interface come together in a surface the agent can actually use. The server is not the knowledge layer; it is the exposure of the knowledge layer to an agent that needs to act.

A good knowledge server is not a big database with an MCP wrapper. It is a small, current, owned, grounded surface — the knowledge the agent needs, in the shape the agent can use, with the basis attached, and with the scope of sharing made explicit. The rest can wait.

Tool-backed knowledge

Not all knowledge is a document the agent reads. Some knowledge is a tool the agent calls — the current value, the current status, the current owner, the thing that is true only when the tool says it is true. Tool-backed knowledge is the knowledge that is true only at the moment of the call, and only if the call returns the right answer.

Tool-backed knowledge is the knowledge layer in action. It is the knowledge that is current by construction — because the tool is the source of truth, and the agent acts on what the tool returns. The discipline is still the same: the agent must know what tool to call, what the tool is authoritative for, what the return means, and what it is permitted to do with it.

The failure mode is not "the tool is wrong." The failure mode is "the agent called the wrong tool, or the right tool for the wrong thing, or treated a tool return as current when it was not, or acted on a tool return it was not permitted to act on." The knowledge layer is what keeps the tool-backed knowledge dependable.

MCP and grounding

MCP is a natural place to carry grounding. When the agent reads from a knowledge server or calls a tool, the basis can be attached — what knowledge was used, from where, at what version, with what permission. The agent does not have to re-derive the basis; the basis comes with the resource, and the agent acts on it with the basis in view.

This is the same discipline as grounding everywhere else — the basis is carried with the action, not re-derived from scratch every time. MCP is one place where that discipline can be applied cleanly, because the server is the point of exposure and the point of grounding at the same time. The server says what it exposed, and the agent acts on what it exposed, with the basis attached.

MCP and discoverability

Discoverability is the discipline that makes knowledge usable by agents at a distance. If an agent engine cannot find a knowledge server, cannot tell what it exposes, cannot tell how to ask, then the knowledge is visible but not usable. MCP is one place where discoverability can be made explicit — the server exposes not just knowledge, but a surface the agent can discover and use.

This is where the agent interface and the discoverability layer from the standards page meet MCP. The knowledge server is the surface. The discoverability layer is what makes the surface findable. The agent interface is what makes the surface usable. The three are not the same, but they meet at the server, and the server is the point where knowledge becomes actable rather than merely visible.

MCP is not the knowledge layer

It is worth saying plainly: MCP is not the knowledge layer. MCP is an exposure mechanism. The knowledge layer is the discipline that makes what is exposed dependable — current, owned, grounded, permitted. A knowledge server that exposes the wrong knowledge in a disciplined way is still exposing the wrong knowledge.

The same is true of RAG, of direct interfaces, of A2A, of any other mechanism an agent uses to get knowledge. The mechanism is not the discipline. The discipline is the knowledge layer: what is true, what is current, what is owned, what is permitted, what to do when the system does not know. The mechanism is how the agent gets it.

MCP is a good mechanism for exposure. It is not a substitute for the knowledge layer. The point of this page is to keep that distinction clear — because it is the distinction that keeps an agent from acting on a well-exposed wrong thing.

Where to start

If you are exposing knowledge through MCP and you are wondering where to start, the usual sequence is:

• Pick one knowledge domain the agent will need — one procedure, one value, one owner, one permission. Not the whole company. One domain.
• Expose it as a knowledge server, in the shape the agent can use, with the basis attached — what knowledge, from where, at what version, with what permission.
• Put currentness, ownership, and permission on the exposed knowledge before the agent acts — not after. The basis is carried with the resource.
• Make the surface discoverable — what it exposes, how to ask, what it is authoritative for, what it is not permitted to share. The agent interface is what makes the surface usable.
• Put the lifecycle on the knowledge — creation, representation, extraction, updates, deprecation — so the surface does not age the moment it is exposed.

The goal is not a general knowledge server for everything. The goal is a dependable exposure for the knowledge the agent needs — in a way that the disciplines can be carried to the next domain without starting over.