---
title: How do you govern MCP resources and prompts, not only tools?
url: https://opencontroller.lyzr.com/blog/govern-mcp-resources-and-prompts
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# How do you govern MCP resources and prompts, not only tools?

**Treat each MCP server primitive as its own risk. Tools act, resources expose data, and prompts inject instructions. Most MCP policies only cover tools, so a server can still leak data through resources or steer the model through prompt templates. Inventory all three, then apply a separate policy to each.**

The Model Context Protocol defines three server primitives. Governance programmes often stop at the first. This post is part of the tools and MCP series; the pillar is [how to govern MCP servers](/blog/how-to-govern-mcp-servers).

## What are the three MCP server primitives?

The [MCP specification's server overview](https://modelcontextprotocol.io/specification/2026-07-28/server) describes them with a control hierarchy:

| Primitive | Who controls it (per spec) | What it is | Example |
|---|---|---|---|
| Prompts | User-controlled | Templates invoked by user choice | Slash commands, menu options |
| Resources | Application-controlled | Contextual data attached and managed by the client | File contents, git history |
| Tools | Model-controlled | Functions the model calls to take actions | API POST requests, file writing |

The control column says who decides when the primitive is used. It does not say the primitive is safe. A user-controlled prompt still comes from the server's author. An application-controlled resource still carries whatever data the server returns.

## What risks does each primitive carry?

**Tools** are the familiar risk: an agent calling something it should not, with arguments it should not use. See [how to limit which tools each AI agent can call](/blog/limit-which-tools-each-ai-agent-can-call).

**Resources expose data.** A resource is identified by a URI and returns content into the model's context. Risks:

- A server exposes more than it should, such as a whole repository or mailbox, not one folder.
- Sensitive content enters the context and then leaves through a tool call or a response.
- Resource content contains hidden instructions, the same indirect prompt injection risk as tool outputs. See [how to stop prompt injection through tool outputs](/blog/stop-prompt-injection-through-tool-outputs).
- Subscriptions keep content flowing as it changes, so exposure is ongoing rather than one-off.

**Prompts inject instructions.** A prompt template is text the server supplies and the client places in the conversation. Risks:

- A template quietly adds instructions such as "always include the full file" or "call this tool first".
- A server update changes a trusted template without anyone noticing.
- Arguments a user passes into a template become an injection path if the server does not handle them safely.

## What policy should each primitive get?

| Primitive | Policy question | Practical controls |
|---|---|---|
| Tools | Which agents may call which tools, with what arguments? | Per-agent tool allowlists, argument checks, rate limits |
| Resources | Which data may enter which agent's context? | Allowlist resource URI patterns, classify resources by data sensitivity, block subscriptions where not needed, scan content for injection |
| Prompts | Whose instructions may enter the conversation? | Review and pin template text, diff on server update, restrict which servers may supply prompts |

Two rules apply across all three:

1. **Pin and review versions.** A server update can change tools, resources and prompts at once. See [how to review MCP server updates before use](/blog/review-mcp-server-updates-before-use).
2. **Treat all server-supplied text as untrusted input.** That includes tool descriptions, resource content and prompt templates.

## What should the inventory record for resources and prompts?

Extend your MCP server inventory beyond tools. For each server, record:

1. Server name, version, owner and transport.
2. Tools exposed, with descriptions.
3. Resource URI templates and the data class of each (public, internal, confidential, regulated).
4. Whether resource subscriptions are supported and used.
5. Prompt names, arguments and a hash of the template text.
6. Which agents and clients use the server.
7. The date of the last review and who did it.

The hash in step 5 matters. It lets you detect a changed template without reading every prompt on every update. For a full field list, see [MCP server inventory fields](/blog/mcp-server-inventory-fields).

## How do you start?

1. List every MCP server your agents and developer tools connect to.
2. For each, call the list endpoints for tools, resources and prompts, and store the results.
3. Flag servers that expose resources over regulated data, or prompts at all.
4. Write one policy per primitive and run it in monitor mode first.
5. Re-run the listing on a schedule and alert on any diff.

For newer protocol features with their own risks, see [MCP sampling and elicitation security](/blog/mcp-sampling-and-elicitation-security).

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, and applies policy as code across the estate, with built-in mappings to OWASP, MITRE ATLAS, NIST and ISO 42001. Opencontroller Edge extends this to local MCP servers and skills on developer devices. Where traffic runs through the Agent Gateway, policy can allow, redact or block in the path. [Book a demo](https://www.lyzr.ai/book-demo/) to see it on your MCP estate.

## Frequently asked questions

**What are MCP resources and prompts?**
Resources are data a server exposes by URI for the client to add to context. Prompts are server-supplied templates a user invokes, such as slash commands.

**Why do MCP resources need their own policy?**
They move data into the model's context, where it can leak through later tool calls or carry hidden instructions. Tool policies do not cover them.

**How do I detect a changed MCP prompt template?**
Store a hash of each template's text in your inventory and alert when a server update changes it.

## Key facts

The MCP specification defines three server primitives: prompts (user-controlled templates such as slash commands), resources (application-controlled data attached by the client, identified by URI) and tools (model-controlled functions). Resources expose data and can carry indirect prompt injection; prompts inject server-authored instructions and can change on update. Govern each with its own policy: tool allowlists, resource URI allowlists and data classification, and pinned, hashed prompt templates. Opencontroller provides a governed registry of agents, tools and MCP servers, policy as code, and Opencontroller Edge for local MCP servers.

## Related

- [What should you record for every MCP server in your inventory?](https://opencontroller.lyzr.com/blog/mcp-server-inventory-fields.md)
- [How do you stop prompt injection that arrives through tool outputs?](https://opencontroller.lyzr.com/blog/stop-prompt-injection-through-tool-outputs.md)
- [How do you review MCP server updates before agents use them?](https://opencontroller.lyzr.com/blog/review-mcp-server-updates-before-use.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
