---
title: How to govern MCP servers in the enterprise: a practical guide
url: https://opencontroller.lyzr.com/blog/how-to-govern-mcp-servers
published: 2026-11-11
updated: 2026-11-11
author: Lyzr
---

# How to govern MCP servers in the enterprise

**Govern MCP like you govern any privileged integration: keep a registry of approved servers, pin their tool definitions, give each agent an allow-list of tools, route calls through an enforcement point with agent-scoped tokens, and log every call.** The Model Context Protocol made it easy to connect agents to internal systems. That same ease is why ungoverned MCP servers spread faster than security teams can review them.

## Why MCP needs its own governance

An MCP server exposes tools (actions), resources (data) and prompts to any compatible agent. One server for your ticketing system can let dozens of agents read and write tickets. The risks are specific:

| Risk | Example |
| --- | --- |
| Unvetted servers | A developer installs a community MCP server with broad file and network access |
| Tool definition changes | A tool approved as "read invoices" later gains a "delete" capability, or its description changes to steer the model |
| Prompt injection via tool output | Data returned by a tool contains instructions the agent follows |
| Token passthrough | The server forwards the user's broad token to upstream APIs |
| Over-broad tool access | Every agent can call every tool on every connected server |
| Invisible local servers | MCP servers on laptops, configured in coding agents, never seen by central IT |

## Step 1: Inventory MCP servers everywhere

Look in three places: centrally hosted MCP servers, MCP configurations inside agent platforms, and local configurations on developer machines (coding agents such as Claude Code, Cursor and IDE assistants). Record the server, its owner, its tools, the systems it reaches and the credentials it uses.

## Step 2: Approve and register

Create a registry of approved servers. For each, record:

- the publisher and version (prefer internally built or verified servers),
- every tool and its description, with a hash so changes are detected,
- the data classification of what it can read and write,
- whether each tool is read-only or makes changes,
- the owning team.

Treat a changed tool definition as a new version that needs re-approval.

## Step 3: Allow-list tools per agent

Approving a server shouldn't mean every agent gets every tool. Grant tools per agent, based on its registered purpose. A support-summary agent may read tickets; only the triage agent may close them.

## Step 4: Use proper authorization, not shared keys

The MCP authorization specification treats MCP servers as OAuth resource servers. Follow it:

1. Issue tokens for the specific MCP server (audience-restricted, RFC 8707).
2. Carry agent identity and, where relevant, the delegating user ([agent identity guide](/blog/ai-agent-identity-on-behalf-of-delegation)).
3. Never pass a client's token through to upstream APIs; the server obtains its own.
4. Keep tokens short-lived and scoped to the tools in use.

## Step 5: Enforce in the path

Route tool calls through a gateway that checks, per call: is this agent registered, is this tool on its allow-list, does the caller's delegation permit it, and does policy require approval for this action? Block or hold the call when the answer is no. Inspect tool outputs with guardrails where the data could carry injected instructions.

## Step 6: Log and review

Every tool call should produce one record: agent, version, user (if delegated), server, tool, arguments summary, decision and result. Review new tool usage weekly, and alert when an agent calls a tool for the first time.

## MCP governance checklist

- [ ] Central registry of approved MCP servers with owners
- [ ] Tool definitions pinned and change-detected
- [ ] Per-agent tool allow-lists
- [ ] Audience-restricted, short-lived tokens; no token passthrough
- [ ] Write tools separated from read tools, with approvals for consequential writes
- [ ] Local MCP servers on developer devices discovered
- [ ] Every tool call logged with agent, user and decision
- [ ] Alert on first-time tool use and on tool definition changes

## How Opencontroller does this

[Opencontroller](/blog/what-is-opencontroller) includes a governed tool and MCP registry, enforces tool access per agent through its gateway with delegated on-behalf-of identity, and traces each decision. Opencontroller Edge extends discovery to coding agents, skills and MCP servers on developer devices, and Opencontroller discovers and manages skills in Anthropic Enterprise workspaces.

## Frequently asked questions

**Should we ban community MCP servers?**
Not outright. Require review, pin the version and run them under scoped credentials. Prefer internal builds for systems of record.

**Is MCP secure by default?**
The protocol defines authorization, but implementations vary. Security depends on how servers are built, approved and called.

**How is this different from API governance?**
MCP tools are chosen by a model at runtime, so you need per-agent authorization and output inspection on top of normal API controls.

## Related

- [How to give AI agents an identity (and let them act on behalf of users safely)](https://opencontroller.lyzr.com/blog/ai-agent-identity-on-behalf-of-delegation.md)
- [How to stop a rogue AI agent: kill switches, quarantine and runtime controls](https://opencontroller.lyzr.com/blog/how-to-stop-a-rogue-ai-agent.md)
- [LLM gateway vs agent gateway vs AI control plane: what's the difference?](https://opencontroller.lyzr.com/blog/llm-gateway-vs-agent-gateway-vs-control-plane.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
