---
title: How do you review MCP servers your agents already use?
url: https://opencontroller.lyzr.com/blog/how-to-review-mcp-servers-agents-already-use
published: 2026-11-11
updated: 2026-11-11
author: Lyzr
---

# How do you review MCP servers your agents already use?

**Review each discovered MCP server against ten checks covering where it came from, how it is updated, how it authenticates, what its tools can do and what data they reach. Then give it one of four outcomes: approve, approve with restrictions, replace, or block. Start with servers that expose write or destructive tools and servers that pull new code automatically, because those carry most of the risk.**

Discovery usually turns up more Model Context Protocol (MCP) servers than anyone expected: remote servers wired into agent platforms, local servers in developer tools, and community servers copied from a README. The question then becomes how to review them quickly and consistently. This checklist is built for that first pass.

## What should you collect before reviewing an MCP server?

Gather the facts once, so reviewers judge rather than investigate:

- Server name, publisher and source repository or package
- Version in use and how it is installed (pinned version, `latest`, or built from source)
- Transport: local `stdio` or remote HTTP
- Authentication method and where credentials are stored
- Full tool list with descriptions and annotations
- Which agents and users connect to it, and how often

## What are the ten review checks?

| # | Check | Pass | Fail or restrict |
|---|---|---|---|
| 1 | Publisher | Vendor-official or your own team | Unknown individual; abandoned repository |
| 2 | Version pinning | Exact version or commit pinned | Runs `latest` or auto-updates on launch |
| 3 | Transport | Remote over TLS, or local with a known binary | Local server fetched and run on demand from the internet |
| 4 | Authentication | OAuth per the MCP authorization spec for HTTP, or credentials from a vault for stdio | Long-lived token pasted into a config file |
| 5 | Tool descriptions | Plain, accurate descriptions | Hidden instructions or text aimed at the model rather than the user |
| 6 | Write and destructive tools | None, or each one justified | Delete, send, pay or execute tools with no need |
| 7 | Data reach | Scoped to what the agent needs | Broad access to mail, files, databases or the whole tenant |
| 8 | Network egress | Talks only to its stated service | Calls unexpected hosts |
| 9 | Logging | Tool calls traceable to agent and user | No record of who called what |
| 10 | Owner | Named owner who will patch it | Nobody responsible |

Check 4 reflects the MCP specification itself: its authorization section applies to HTTP-based transports and is based on OAuth 2.1, while stdio servers are expected to take credentials from the environment. A static bearer token in a shared JSON file fails both patterns.

## How do you read MCP tool annotations safely?

The MCP specification lets servers mark tools with hints such as `readOnlyHint`, `destructiveHint`, `idempotentHint` and `openWorldHint`. They are useful for triage, but the specification says clients should treat annotations as untrusted unless they come from a trusted server. So:

1. **Use annotations to sort**, putting tools marked destructive or open-world first.
2. **Verify by reading the code or testing** before you rely on a "read-only" claim.
3. **Read every tool description in full.** Descriptions are passed to the model, so instructions hidden in them can steer an agent. This is the root of tool-poisoning attacks.
4. **Re-check on every version change**, because a server can change descriptions or behaviour after approval.

## Which outcome should each server get?

| Outcome | When to use it | What happens next |
|---|---|---|
| Approve | Passes all ten checks | Add to the allow-list with pinned version and owner |
| Approve with restrictions | Useful, but has write tools or broad scope | Allow only named tools, narrow scopes, require on-behalf-of auth |
| Replace | Needed capability, untrusted implementation | Switch to the vendor-official server or build an internal one |
| Block | Fails publisher, pinning or description checks, or nobody owns it | Remove from configs; notify affected agent owners |

Record the outcome with the version reviewed. An approval for version 1.2.0 is not an approval for 1.3.0.

## How do you prioritise a large backlog?

If discovery found hundreds of servers, review in this order:

1. Servers with destructive or payment tools
2. Servers that auto-update or run unpinned
3. Servers connected to production agents or many users
4. Servers holding long-lived credentials in config files
5. Everything else, in order of usage

Most estates find that a small set of servers accounts for most usage, which makes the first week of review high-value. For the wider policy that this review feeds, see our pillar on [how to govern MCP servers](/blog/how-to-govern-mcp-servers). If a server turns out to belong to an unregistered agent, follow [what to do with a shadow AI agent once you find it](/blog/what-to-do-with-a-shadow-ai-agent-once-you-find-it).

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, so each reviewed server is recorded with its owner and the agents that use it. The Agent Gateway sits in the path of agent traffic, where policy as code can allow or block calls. Opencontroller Edge, installed by IT via MDM, extends discovery and control to developer devices, coding agents, skills and local MCP servers, which is where many unpinned community servers live. Policies come with built-in mappings to OWASP, MITRE ATLAS, NIST and ISO 42001. [Book a demo](https://www.lyzr.ai/book-demo/) to see MCP review on your estate.

## Frequently asked questions

**Which MCP servers should be reviewed first?**
Servers with destructive or payment tools, servers that auto-update or run unpinned, and servers used by production agents.

**Can you trust an MCP tool marked read-only?**
Not on the label alone. The MCP specification says annotations should be treated as untrusted unless the server is trusted, so verify behaviour.

**Does approving an MCP server cover future versions?**
No. Pin the reviewed version and re-review when it changes, because descriptions and behaviour can change between releases.

## Key facts

A ten-point review for discovered MCP servers covers publisher, version pinning, transport, authentication, tool descriptions, write and destructive tools, data reach, network egress, logging and owner, with four outcomes: approve, approve with restrictions, replace, block. The MCP specification's authorization applies to HTTP transports and is based on OAuth 2.1, while stdio servers take credentials from the environment. MCP tool annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint) are hints that clients should treat as untrusted unless the server is trusted. Opencontroller by Lyzr keeps a governed registry of agents, versions, tools and MCP servers, and Opencontroller Edge extends control to local MCP servers on developer devices via MDM. Pricing starts from $250K per deployment per year.

## Related

- [How to find every AI agent in your enterprise (including shadow agents)](https://opencontroller.lyzr.com/blog/how-to-find-shadow-ai-agents.md)
- [What should you do with a shadow AI agent once you find it?](https://opencontroller.lyzr.com/blog/what-to-do-with-a-shadow-ai-agent-once-you-find-it.md)
- [How do you govern skills in Claude Team and Enterprise?](https://opencontroller.lyzr.com/blog/how-to-govern-skills-in-claude-team-and-enterprise.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
