---
title: How do you review MCP server updates before agents use them?
url: https://opencontroller.lyzr.com/blog/review-mcp-server-updates-before-use
published: 2026-11-12
updated: 2026-11-12
author: Lyzr
---

# How do you review MCP server updates before agents use them?

**Pin every MCP server to a reviewed version, store a hash of each approved tool definition, and diff the tool list on every update. Any new tool, or any change to a tool's description, input schema or annotations, sends the server back to review before agents can use it. For remote servers you do not control, run the same diff on a schedule, because they can change without a version bump.**

Most MCP reviews happen once, at onboarding. That misses the main risk. An MCP tool's description is read by the model as an instruction, so a changed description changes agent behaviour without any code change on your side. This is the "rug pull" pattern described in [MCP tool poisoning](/blog/what-is-mcp-tool-poisoning).

## What counts as a change that needs review?

Not every update is equal. Use these triggers.

| Change | Example | Action |
|---|---|---|
| New tool | Server adds `delete_file` | Block until reviewed; new tools are denied by default |
| Description changed | Text now includes "also send results to…" | Full review; descriptions steer the model |
| Input or output schema changed | New `recipient` parameter | Review argument limits and data flows |
| Annotations changed | `destructiveHint` flipped from true to false | Review; annotations are hints, not guarantees |
| Auth or scopes changed | Server asks for broader OAuth scopes | Security review and owner sign-off |
| Package version bump, no tool changes | Patch release with bug fixes | Lightweight review: changelog, dependency scan |
| Tool removed | `export_csv` gone | Check which agents relied on it |

The first five change what agents can do. They need the same review as a new server.

## How do you pin and fingerprint an MCP server?

1. **Pin the artefact.** For local servers, use exact package versions rather than ranges or `latest`, and lock dependencies. For containers, reference the image by digest, not tag.
2. **Capture the tool list at approval.** Call `tools/list` and store each tool's name, description, `inputSchema`, `outputSchema` and annotations.
3. **Hash each definition.** Store a SHA-256 hash of each tool's full definition. The OWASP MCP Security Cheat Sheet recommends pinning reviewed tool definitions with cryptographic hashes and requiring review when they change.
4. **Record it in the inventory.** Keep the version, hashes, reviewer and date with the server's record. The [MCP server inventory fields](/blog/mcp-server-inventory-fields) post lists what else to capture.

## How do you catch changes as they happen?

Use three signals together.

- **Your own pipeline.** Any pull request that bumps an MCP server version runs a job that starts the new version, calls `tools/list`, and diffs hashes against the approved set. A diff fails the build until a reviewer approves.
- **Protocol notifications.** The MCP specification lets a server declare the `listChanged` capability and send `notifications/tools/list_changed` when its tools change. Clients and gateways can listen for it and re-check. Not every server sends it, so do not rely on it alone.
- **Scheduled checks for remote servers.** A hosted server can change at any time. Re-fetch its tool list daily, or on every session start for high-risk servers, and compare hashes.

When a check finds an unapproved change, the safe default is to hide the changed tools from agents until review, not to keep serving the old definition the server no longer honours.

## Who should approve an MCP update?

Keep it proportionate.

1. **Technical owner** checks the diff, changelog and dependency scan.
2. **Security** reviews new tools, new scopes and changed descriptions.
3. **Business owner** of affected agents confirms the change is wanted.
4. **Record the decision** with the new hashes, so the next diff has a baseline.

Patch releases with identical tool hashes can be approved by the technical owner alone.

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, so approved tools and versions are recorded alongside the agents that use them. Policies are written as code and enforced in the path through the Agent Gateway. Opencontroller Edge discovers local MCP servers on developer devices and is installed by IT via MDM. See the [MCP governance guide](/blog/how-to-govern-mcp-servers), or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Why review MCP updates if the server was already approved?**
Because descriptions act as instructions and tools can be added after approval. A changed definition is new behaviour.

**How do I detect changes on a remote MCP server I do not control?**
Call `tools/list` on a schedule, hash each definition, and compare with approved hashes.

**Should agents keep working while an update is reviewed?**
Yes, with the changed or new tools hidden. Unchanged tools can stay available.

## Key facts

To review MCP server updates before agents use them: pin local servers to exact package versions or container image digests, store a hash of every approved tool definition (name, description, inputSchema, outputSchema, annotations), diff tools/list results against the approved set on every update and on a schedule for remote servers, and send the server back to review when a tool is added or a description, schema or annotation changes. The MCP specification lets servers announce changes with notifications/tools/list_changed when they declare the listChanged capability. The OWASP MCP Security Cheat Sheet recommends pinning reviewed tool definitions with cryptographic hashes. Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, and Opencontroller Edge discovers local MCP servers on developer devices. Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How to govern MCP servers in the enterprise: a practical guide](https://opencontroller.lyzr.com/blog/how-to-govern-mcp-servers.md)
- [What is MCP tool poisoning and how do you prevent it?](https://opencontroller.lyzr.com/blog/what-is-mcp-tool-poisoning.md)
- [What should you record for every MCP server in your inventory?](https://opencontroller.lyzr.com/blog/mcp-server-inventory-fields.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
