Skip to content
← Guides
Guide

How to secure and govern MCP servers that AI agents use

Treat every MCP server as code that runs with your agent’s access. Allow only reviewed servers, scope their credentials and log every tool call.

By Sycamore.

Key takeaways

  • An MCP server extends what every connected agent can do, and the MCP specification treats tools as arbitrary code execution, so each server needs the same review as any third-party code with access to your systems.
  • Authorization is optional in the MCP specification. When an HTTP-based server implements it, the server must accept only tokens issued for that server and must not pass a client’s token on to other services.
  • The public MCP Registry is in preview, does not list private servers and says consumers should assume minimal-to-no moderation, so enterprises need their own registry and allowlist of approved servers and versions.
  • Tool descriptions and annotations are untrusted input unless they come from a trusted server, because misleading descriptions can make agents select tools unreliably and tools can send instructions back to the model.
  • Enforce policy and keep logs in a layer the model cannot change, such as a gateway in front of MCP servers or managed client settings, not in the agent’s prompt.

To secure the MCP servers your AI agents use, treat each server as third-party code that runs with the agent’s access: keep a private registry and allowlist of reviewed servers and versions, give each server its own narrowly scoped, short-lived credentials, and never let a server pass a user’s token through to other services. Then enforce policy and log every tool call in a layer outside the model, such as a gateway or managed client settings. The Model Context Protocol (MCP) defines many of these rules but cannot enforce them, so they are the deploying organization’s job.

Why do MCP servers need their own security controls?

An MCP server gives every agent connected to it new abilities, so its security is the agent’s security. The MCP specification says that “tools represent arbitrary code execution and must be treated with appropriate caution”, and that while MCP “cannot enforce these security principles at the protocol level”, implementers should build consent, access controls and data protection into their applications.1

Government guidance describes the same exposure without naming MCP. Joint guidance from the cyber security agencies of Australia, the United States (CISA and NSA), Canada, New Zealand and the United Kingdom describes a scenario in which an attacker “compromises a low-risk tool integrated into the agent’s workflow” and inherits the agent’s excessive privileges, and warns that “unvetted third-party components may carry excessive or unintended privileges when integrated into agent workflows”.2

Official MCP software has had serious flaws too, which is a reason to track versions and patch quickly:

  • MCP Inspector, a developer tool for testing MCP servers, was vulnerable below version 0.14.1 to remote code execution because there was no authentication between its client and proxy (CVE-2025-49596).3
  • The official TypeScript SDK before 1.24.0 did not enable DNS rebinding protection by default for HTTP-based servers (CVE-2025-66414).4
  • The project’s Git server, mcp-server-git, did not check before version 2025.12.17 that tool calls stayed inside the repository it was restricted to with the --repository flag (CVE-2025-68145).5

What are the main security risks with MCP servers?

Most MCP risks come from four places: credentials, the tools a server advertises, where servers run, and servers nobody approved. The MCP project’s own security guidance and OWASP’s MCP Top 10, a list the project describes as in beta, name the main ones.67

Risk What happens Main control
Token passthrough A server accepts a token that was not issued to it and forwards it to a downstream API, bypassing that API’s controls and blurring the audit trail. Servers accept only tokens issued for them and get their own credentials for upstream calls.
Confused deputy A proxy server with one shared OAuth client lets an attacker reuse a user’s earlier consent and capture the authorization code. Per-client consent before forwarding to a third-party authorization server.
Tool poisoning A tool’s description or output carries instructions that manipulate the model. Treat descriptions and results as untrusted; review servers before approval.
Lookalike servers Attackers publish malicious tools or agents under legitimate or similar names. Allow only named, verified servers and versions.
Local server compromise A one-click install runs a malicious command on the user’s machine with the client’s privileges. Show the exact command, require consent, run servers sandboxed with minimal default privileges.
Over-broad scopes Wildcard or omnibus scopes make a stolen token far more useful and hide what each call needed. Request minimal scopes and elevate only when an operation needs it.
Shadow MCP servers Teams run servers outside security governance, so nobody knows what agents can reach. Discovery and a registry of approved servers.

The table draws on the MCP security best practices for token passthrough, confused deputy, local server compromise and scope minimization,6 on OWASP’s MCP Top 10 for tool poisoning and shadow MCP servers,7 and on the joint guidance for misleading tool descriptions and lookalike tools, which it calls tool or agent “squatting”.2

How do you decide which MCP servers are allowed?

Keep a private registry of approved servers, pinned to versions you have reviewed, and block everything else. The joint guidance recommends that organizations “maintain a trusted registry of third-party components” and “restrict tool use to an approved allow list of tools and versions that are regularly verified as secure”.2

The public MCP Registry does not do this for you. It is in preview, it “does not support private servers”, and it delegates security scanning to package registries and downstream aggregators.8 Its moderation policy says consumers “should assume minimal-to-no moderation”, and lists servers with security vulnerabilities among the things it will not remove.9 Use it to find servers, not to approve them. Platform vendors put the decision on you as well: Microsoft’s Copilot Studio documentation says that when you connect to an external MCP server, “you’re responsible for the tools and resources you access”.10

A review before approval should cover:

  1. Who publishes and runs it. The vendor, the package source and whether the server is local or hosted.
  2. What it can do. Each tool, whether it reads or writes, and which systems and data it reaches.
  3. How it authenticates. Whether it implements MCP authorization, which scopes it requests and where it stores credentials.
  4. Which version you approved. Pin it, and review again before upgrading.
  5. Who owns it inside the company. A named owner who answers for it and retires it. For building the wider register, see how to find and inventory every AI agent in your company.

Then enforce the list where agents connect. Major clients and platforms now offer central controls:

  • Claude Code lets administrators set an allowlist and denylist of MCP servers in managed settings. Anthropic’s documentation says that by default “anyone running Claude Code can connect any MCP server they choose”, that Anthropic reviews connectors against its listing criteria but “doesn’t security-audit or manage any MCP server”, that a server matching any denylist entry is blocked, and that a server’s name alone “is not a security control”.11
  • GitHub Copilot can restrict MCP use to servers in a custom registry. GitHub labels this a public preview and says the more secure, generally available method is its enterprise managed settings file.12
  • Microsoft Copilot Studio applies data policies to MCP tools: blocking Power Platform connectors also blocks access to tools in connected MCP servers, which rely on those connectors for connectivity.13
  • Google Cloud IAM allow and deny policies can control calls to Google Cloud’s own MCP servers, for example denying every tool that is not read-only. The same page says IAM cannot control access to MCP servers outside Google Cloud.14

How should MCP servers handle credentials?

Each server should accept only tokens issued for it and use its own credentials for anything it calls. Authorization is optional in the MCP specification, but when an HTTP-based server implements it, the server “MUST validate that access tokens were issued specifically for them as the intended audience” and “MUST NOT accept or transit any other tokens”.15 Servers that run locally over standard input and output should not use the specification’s OAuth flow and should “instead retrieve credentials from the environment”.15

The MCP security guidance calls token passthrough “an anti-pattern” and lists what it breaks: rate limits and other controls in downstream services are bypassed, and the server cannot identify or distinguish between clients.6 In practice:

  • Use short-lived tokens. The specification’s security considerations say authorization servers should issue short-lived access tokens to reduce the impact of leaks.16
  • Keep scopes small. The MCP guidance lists publishing every possible scope and using wildcard or “omnibus” scopes such as *, all or full-access as common mistakes.6
  • Separate agent and user authority. When a server acts for a person, record both identities. For how delegation should work, see how to give AI agents identities and permissions.

Where should MCP policy be enforced at runtime?

In a layer the model cannot rewrite: a gateway in front of MCP servers, the systems the servers call, or managed settings in the client. Tool descriptions and results reach the model as input. The joint guidance warns that tools can “send potentially arbitrary instructions back to the LLM” and that “poor or deliberately misleading tool descriptions can cause agents to select tools unreliably”.2 The MCP specification says descriptions of tool behavior “should be considered untrusted, unless obtained from a trusted server”.1 A rule written only into the agent’s prompt is exposed to that same input, so it is not a control.

The MCP tools specification sets a baseline for both sides. Servers must validate tool inputs, implement access controls, rate limit tool calls and sanitize outputs. Clients should show tool inputs to the user before calling the server, validate tool results before passing them to the model, and log tool use for audit. It also says there “SHOULD always be a human in the loop with the ability to deny tool invocations”.17 For tools that are hard to undo, such as payments, deletions or messages to customers, make that approval a real step rather than a default.

Gateways can carry these rules for many servers at once. Azure API Management can expose and govern access to MCP servers and their tools, and can use its credential manager to inject OAuth tokens for the backend calls that tools make.18 Amazon Bedrock AgentCore Gateway handles inbound authentication of agents and outbound authentication to tools in one service.19 Check that any gateway you use does not forward the client’s token to the backend server, which would recreate the passthrough problem. For the wider set of runtime controls, see how to govern AI agents in production.

What should you log and monitor?

Log every tool call with the agent, the user it acted for, the server, the tool, the inputs, the result and the policy decision, in storage the agent cannot change. The joint guidance recommends logging agent tool usage in a human-readable format and setting up protocols that automatically restrict an agent’s permissions when it behaves unexpectedly.2 OWASP lists a lack of audit and telemetry as one of its ten MCP risks.7

Watch in particular for:

  • New servers appearing on endpoints or in client configurations that are not in your registry.
  • Scope elevation. The MCP guidance recommends that servers log each elevation event, with the scope requested and the subset granted.6
  • Changed tool descriptions between versions of an approved server, which should trigger a new review.
  • Unusual tool use, such as a read-only agent attempting writes or a sudden rise in calls.

Where Sycamore fits

Sycamore Govern is an AI governance control plane. Its discovery step inventories AI use cases, agents, applications, models, connectors and MCP servers, and each record connects ownership, versions, capabilities, tools, data access and activity while separating declared intent from observed behavior. Govern gives every agent an identity, with model, tool and data access routed through policy, and can stop an agent by revoking its identity, pausing execution, removing a connection or blocking the model and tool paths it needs. It keeps a tamper-evident record of approvals, policy checks, access, changes and revocations.

Teams building agents in Sycamore Build connect to existing systems through approved connectors, APIs and MCP tools, respecting the organization’s identity, permissions and data boundaries.

Frequently asked questions

Should we let agents use servers listed in the public MCP Registry?

Use the registry to find servers, not to approve them. It is in preview, does not list private servers, delegates security scanning to package registries and other downstream services, and tells consumers to assume minimal-to-no moderation. Review a server you find there like any other third-party code, then add the version you approved to your own registry.

Are local MCP servers safer than remote ones?

Not by default. A local server runs on the user’s machine with the same privileges as the client that starts it, so a malicious or compromised package runs with that access. The MCP security guidance says clients must show the exact command before a one-click install of a local server, and should run the server in a sandbox with minimal default privileges.

Should we ban MCP servers until the standard matures?

A blanket ban risks pushing use out of sight, and OWASP’s MCP Top 10 lists unapproved deployments outside security governance, which it calls shadow MCP servers, as a risk in its own right. A more durable approach is to allow a short list of reviewed servers through managed settings or a gateway, block everything else, and widen the list as teams submit servers for review.

How often should an approved MCP server be reviewed again?

Whenever its version, tools, tool descriptions or requested scopes change, and on a regular schedule otherwise. The joint guidance from the Five Eyes cyber security agencies recommends an allow list of tools and versions that are regularly verified as secure, so pin versions and treat each upgrade as a new approval. Patch quickly when an advisory affects a server or SDK you use.

Sources

  1. Model Context Protocol, “Specification”, version 2026-07-28, “Security and Trust & Safety”, https://modelcontextprotocol.io/specification/2026-07-28

  2. Australian Signals Directorate’s Australian Cyber Security Centre, CISA, NSA, Canadian Centre for Cyber Security, NCSC-NZ and NCSC-UK, “Careful adoption of agentic AI services” (pp. 8, 9, 11, 18), https://www.ncsc.govt.nz/assets/guidance/Documents/Careful-adoption-of-agentic-AI-services_FINAL.pdf

  3. NIST National Vulnerability Database, “CVE-2025-49596”, https://nvd.nist.gov/vuln/detail/CVE-2025-49596

  4. NIST National Vulnerability Database, “CVE-2025-66414”, https://nvd.nist.gov/vuln/detail/CVE-2025-66414

  5. NIST National Vulnerability Database, “CVE-2025-68145”, https://nvd.nist.gov/vuln/detail/CVE-2025-68145

  6. Model Context Protocol, “Security Best Practices”, version 2026-07-28, https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices

  7. OWASP, “OWASP MCP Top 10”, https://owasp.org/projects/mcp-top-10

  8. Model Context Protocol, “The MCP Registry”, https://modelcontextprotocol.io/registry/about

  9. Model Context Protocol, “The MCP Registry Moderation Policy”, https://modelcontextprotocol.io/registry/moderation-policy

  10. Microsoft Learn, “Extend your agent with Model Context Protocol”, Copilot Studio documentation, https://learn.microsoft.com/en-us/microsoft-copilot-studio/agent-extend-action-mcp

  11. Anthropic, “Control MCP server access for your organization”, Claude Code documentation, https://code.claude.com/docs/en/managed-mcp

  12. GitHub Docs, “Restrict MCP server access to a custom registry”, https://docs.github.com/en/copilot/how-tos/administer-copilot/manage-mcp-usage/restrict-based-on-registry

  13. Microsoft Learn, “Configure data policies for agents”, Copilot Studio documentation, https://learn.microsoft.com/en-us/microsoft-copilot-studio/admin-data-loss-prevention

  14. Google Cloud, “Control MCP use with Identity and Access Management”, https://docs.cloud.google.com/mcp/control-mcp-use-iam

  15. Model Context Protocol, “Authorization”, specification version 2026-07-28, https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization

  16. Model Context Protocol, “Authorization Security Considerations”, specification version 2026-07-28, https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/security-considerations

  17. Model Context Protocol, “Tools”, specification version 2026-07-28, https://modelcontextprotocol.io/specification/2026-07-28/server/tools

  18. Microsoft Learn, “Secure access to MCP servers in Azure API Management”, https://learn.microsoft.com/en-us/azure/api-management/secure-mcp-servers

  19. AWS, “Amazon Bedrock AgentCore Gateway”, Amazon Bedrock AgentCore Developer Guide, https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway.html

# How to secure and govern MCP servers that AI agents use

Treat every MCP server as code that runs with your agent's access. Allow only reviewed servers, scope their credentials and log every tool call.

## Key takeaways

- An MCP server extends what every connected agent can do, and the MCP specification treats tools as arbitrary code execution, so each server needs the same review as any third-party code with access to your systems.
- Authorization is optional in the MCP specification. When an HTTP-based server implements it, the server must accept only tokens issued for that server and must not pass a client's token on to other services.
- The public MCP Registry is in preview, does not list private servers and says consumers should assume minimal-to-no moderation, so enterprises need their own registry and allowlist of approved servers and versions.
- Tool descriptions and annotations are untrusted input unless they come from a trusted server, because misleading descriptions can make agents select tools unreliably and tools can send instructions back to the model.
- Enforce policy and keep logs in a layer the model cannot change, such as a gateway in front of MCP servers or managed client settings, not in the agent's prompt.

To secure the MCP servers your AI agents use, treat each server as third-party code that runs with the agent's access: keep a private registry and allowlist of reviewed servers and versions, give each server its own narrowly scoped, short-lived credentials, and never let a server pass a user's token through to other services. Then enforce policy and log every tool call in a layer outside the model, such as a gateway or managed client settings. The Model Context Protocol (MCP) defines many of these rules but cannot enforce them, so they are the deploying organization's job.

## Why do MCP servers need their own security controls?

An MCP server gives every agent connected to it new abilities, so its security is the agent's security. The MCP specification says that "tools represent arbitrary code execution and must be treated with appropriate caution", and that while MCP "cannot enforce these security principles at the protocol level", implementers should build consent, access controls and data protection into their applications.[^mcp-spec]

Government guidance describes the same exposure without naming MCP. Joint guidance from the cyber security agencies of Australia, the United States (CISA and NSA), Canada, New Zealand and the United Kingdom describes a scenario in which an attacker "compromises a low-risk tool integrated into the agent's workflow" and inherits the agent's excessive privileges, and warns that "unvetted third-party components may carry excessive or unintended privileges when integrated into agent workflows".[^five-eyes]

Official MCP software has had serious flaws too, which is a reason to track versions and patch quickly:

- MCP Inspector, a developer tool for testing MCP servers, was vulnerable below version 0.14.1 to remote code execution because there was no authentication between its client and proxy (CVE-2025-49596).[^cve-inspector]
- The official TypeScript SDK before 1.24.0 did not enable DNS rebinding protection by default for HTTP-based servers (CVE-2025-66414).[^cve-sdk]
- The project's Git server, mcp-server-git, did not check before version 2025.12.17 that tool calls stayed inside the repository it was restricted to with the `--repository` flag (CVE-2025-68145).[^cve-git]

## What are the main security risks with MCP servers?

Most MCP risks come from four places: credentials, the tools a server advertises, where servers run, and servers nobody approved. The MCP project's own security guidance and OWASP's MCP Top 10, a list the project describes as in beta, name the main ones.[^mcp-security][^owasp-mcp]

| Risk                    | What happens                                                                                                                                        | Main control                                                                                    |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| Token passthrough       | A server accepts a token that was not issued to it and forwards it to a downstream API, bypassing that API's controls and blurring the audit trail. | Servers accept only tokens issued for them and get their own credentials for upstream calls.    |
| Confused deputy         | A proxy server with one shared OAuth client lets an attacker reuse a user's earlier consent and capture the authorization code.                     | Per-client consent before forwarding to a third-party authorization server.                     |
| Tool poisoning          | A tool's description or output carries instructions that manipulate the model.                                                                      | Treat descriptions and results as untrusted; review servers before approval.                    |
| Lookalike servers       | Attackers publish malicious tools or agents under legitimate or similar names.                                                                      | Allow only named, verified servers and versions.                                                |
| Local server compromise | A one-click install runs a malicious command on the user's machine with the client's privileges.                                                    | Show the exact command, require consent, run servers sandboxed with minimal default privileges. |
| Over-broad scopes       | Wildcard or omnibus scopes make a stolen token far more useful and hide what each call needed.                                                      | Request minimal scopes and elevate only when an operation needs it.                             |
| Shadow MCP servers      | Teams run servers outside security governance, so nobody knows what agents can reach.                                                               | Discovery and a registry of approved servers.                                                   |

The table draws on the MCP security best practices for token passthrough, confused deputy, local server compromise and scope minimization,[^mcp-security] on OWASP's MCP Top 10 for tool poisoning and shadow MCP servers,[^owasp-mcp] and on the joint guidance for misleading tool descriptions and lookalike tools, which it calls tool or agent "squatting".[^five-eyes]

## How do you decide which MCP servers are allowed?

Keep a private registry of approved servers, pinned to versions you have reviewed, and block everything else. The joint guidance recommends that organizations "maintain a trusted registry of third-party components" and "restrict tool use to an approved allow list of tools and versions that are regularly verified as secure".[^five-eyes]

The public MCP Registry does not do this for you. It is in preview, it "does not support private servers", and it delegates security scanning to package registries and downstream aggregators.[^mcp-registry] Its moderation policy says consumers "should assume minimal-to-no moderation", and lists servers with security vulnerabilities among the things it will not remove.[^mcp-moderation] Use it to find servers, not to approve them. Platform vendors put the decision on you as well: Microsoft's Copilot Studio documentation says that when you connect to an external MCP server, "you're responsible for the tools and resources you access".[^copilot-mcp]

A review before approval should cover:

1. **Who publishes and runs it.** The vendor, the package source and whether the server is local or hosted.
2. **What it can do.** Each tool, whether it reads or writes, and which systems and data it reaches.
3. **How it authenticates.** Whether it implements MCP authorization, which scopes it requests and where it stores credentials.
4. **Which version you approved.** Pin it, and review again before upgrading.
5. **Who owns it inside the company.** A named owner who answers for it and retires it. For building the wider register, see [how to find and inventory every AI agent in your company](/guides/ai-agent-inventory/).

Then enforce the list where agents connect. Major clients and platforms now offer central controls:

- **Claude Code** lets administrators set an allowlist and denylist of MCP servers in managed settings. Anthropic's documentation says that by default "anyone running Claude Code can connect any MCP server they choose", that Anthropic reviews connectors against its listing criteria but "doesn't security-audit or manage any MCP server", that a server matching any denylist entry is blocked, and that a server's name alone "is not a security control".[^claude-managed]
- **GitHub Copilot** can restrict MCP use to servers in a custom registry. GitHub labels this a public preview and says the more secure, generally available method is its enterprise managed settings file.[^github-registry]
- **Microsoft Copilot Studio** applies data policies to MCP tools: blocking Power Platform connectors also blocks access to tools in connected MCP servers, which rely on those connectors for connectivity.[^copilot-dlp]
- **Google Cloud** IAM allow and deny policies can control calls to Google Cloud's own MCP servers, for example denying every tool that is not read-only. The same page says IAM cannot control access to MCP servers outside Google Cloud.[^gcp-iam]

## How should MCP servers handle credentials?

Each server should accept only tokens issued for it and use its own credentials for anything it calls. Authorization is optional in the MCP specification, but when an HTTP-based server implements it, the server "MUST validate that access tokens were issued specifically for them as the intended audience" and "MUST NOT accept or transit any other tokens".[^mcp-auth] Servers that run locally over standard input and output should not use the specification's OAuth flow and should "instead retrieve credentials from the environment".[^mcp-auth]

The MCP security guidance calls token passthrough "an anti-pattern" and lists what it breaks: rate limits and other controls in downstream services are bypassed, and the server cannot identify or distinguish between clients.[^mcp-security] In practice:

- **Use short-lived tokens.** The specification's security considerations say authorization servers should issue short-lived access tokens to reduce the impact of leaks.[^mcp-auth-sec]
- **Keep scopes small.** The MCP guidance lists publishing every possible scope and using wildcard or "omnibus" scopes such as `*`, `all` or `full-access` as common mistakes.[^mcp-security]
- **Separate agent and user authority.** When a server acts for a person, record both identities. For how delegation should work, see [how to give AI agents identities and permissions](/guides/ai-agent-identity-and-permissions/).

## Where should MCP policy be enforced at runtime?

In a layer the model cannot rewrite: a gateway in front of MCP servers, the systems the servers call, or managed settings in the client. Tool descriptions and results reach the model as input. The joint guidance warns that tools can "send potentially arbitrary instructions back to the LLM" and that "poor or deliberately misleading tool descriptions can cause agents to select tools unreliably".[^five-eyes] The MCP specification says descriptions of tool behavior "should be considered untrusted, unless obtained from a trusted server".[^mcp-spec] A rule written only into the agent's prompt is exposed to that same input, so it is not a control.

The MCP tools specification sets a baseline for both sides. Servers must validate tool inputs, implement access controls, rate limit tool calls and sanitize outputs. Clients should show tool inputs to the user before calling the server, validate tool results before passing them to the model, and log tool use for audit. It also says there "SHOULD always be a human in the loop with the ability to deny tool invocations".[^mcp-tools] For tools that are hard to undo, such as payments, deletions or messages to customers, make that approval a real step rather than a default.

Gateways can carry these rules for many servers at once. Azure API Management can expose and govern access to MCP servers and their tools, and can use its credential manager to inject OAuth tokens for the backend calls that tools make.[^azure-apim] Amazon Bedrock AgentCore Gateway handles inbound authentication of agents and outbound authentication to tools in one service.[^agentcore-gateway] Check that any gateway you use does not forward the client's token to the backend server, which would recreate the passthrough problem. For the wider set of runtime controls, see [how to govern AI agents in production](/guides/how-to-govern-ai-agents/).

## What should you log and monitor?

Log every tool call with the agent, the user it acted for, the server, the tool, the inputs, the result and the policy decision, in storage the agent cannot change. The joint guidance recommends logging agent tool usage in a human-readable format and setting up protocols that automatically restrict an agent's permissions when it behaves unexpectedly.[^five-eyes] OWASP lists a lack of audit and telemetry as one of its ten MCP risks.[^owasp-mcp]

Watch in particular for:

- **New servers** appearing on endpoints or in client configurations that are not in your registry.
- **Scope elevation.** The MCP guidance recommends that servers log each elevation event, with the scope requested and the subset granted.[^mcp-security]
- **Changed tool descriptions** between versions of an approved server, which should trigger a new review.
- **Unusual tool use**, such as a read-only agent attempting writes or a sudden rise in calls.

## Where Sycamore fits

[Sycamore Govern](/govern/) is an AI governance control plane. Its discovery step inventories AI use cases, agents, applications, models, connectors and MCP servers, and each record connects ownership, versions, capabilities, tools, data access and activity while separating declared intent from observed behavior. Govern gives every agent an identity, with model, tool and data access routed through policy, and can stop an agent by revoking its identity, pausing execution, removing a connection or blocking the model and tool paths it needs. It keeps a tamper-evident record of approvals, policy checks, access, changes and revocations.

Teams building agents in [Sycamore Build](/build/) connect to existing systems through approved connectors, APIs and MCP tools, respecting the organization's identity, permissions and data boundaries.

[^mcp-spec]: Model Context Protocol, "Specification", version 2026-07-28, "Security and Trust & Safety", https://modelcontextprotocol.io/specification/2026-07-28

[^five-eyes]: Australian Signals Directorate's Australian Cyber Security Centre, CISA, NSA, Canadian Centre for Cyber Security, NCSC-NZ and NCSC-UK, "Careful adoption of agentic AI services" (pp. 8, 9, 11, 18), https://www.ncsc.govt.nz/assets/guidance/Documents/Careful-adoption-of-agentic-AI-services_FINAL.pdf

[^cve-inspector]: NIST National Vulnerability Database, "CVE-2025-49596", https://nvd.nist.gov/vuln/detail/CVE-2025-49596

[^cve-sdk]: NIST National Vulnerability Database, "CVE-2025-66414", https://nvd.nist.gov/vuln/detail/CVE-2025-66414

[^cve-git]: NIST National Vulnerability Database, "CVE-2025-68145", https://nvd.nist.gov/vuln/detail/CVE-2025-68145

[^mcp-security]: Model Context Protocol, "Security Best Practices", version 2026-07-28, https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices

[^owasp-mcp]: OWASP, "OWASP MCP Top 10", https://owasp.org/projects/mcp-top-10

[^mcp-registry]: Model Context Protocol, "The MCP Registry", https://modelcontextprotocol.io/registry/about

[^mcp-moderation]: Model Context Protocol, "The MCP Registry Moderation Policy", https://modelcontextprotocol.io/registry/moderation-policy

[^claude-managed]: Anthropic, "Control MCP server access for your organization", Claude Code documentation, https://code.claude.com/docs/en/managed-mcp

[^github-registry]: GitHub Docs, "Restrict MCP server access to a custom registry", https://docs.github.com/en/copilot/how-tos/administer-copilot/manage-mcp-usage/restrict-based-on-registry

[^copilot-dlp]: Microsoft Learn, "Configure data policies for agents", Copilot Studio documentation, https://learn.microsoft.com/en-us/microsoft-copilot-studio/admin-data-loss-prevention

[^copilot-mcp]: Microsoft Learn, "Extend your agent with Model Context Protocol", Copilot Studio documentation, https://learn.microsoft.com/en-us/microsoft-copilot-studio/agent-extend-action-mcp

[^gcp-iam]: Google Cloud, "Control MCP use with Identity and Access Management", https://docs.cloud.google.com/mcp/control-mcp-use-iam

[^mcp-auth]: Model Context Protocol, "Authorization", specification version 2026-07-28, https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization

[^mcp-auth-sec]: Model Context Protocol, "Authorization Security Considerations", specification version 2026-07-28, https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/security-considerations

[^mcp-tools]: Model Context Protocol, "Tools", specification version 2026-07-28, https://modelcontextprotocol.io/specification/2026-07-28/server/tools

[^azure-apim]: Microsoft Learn, "Secure access to MCP servers in Azure API Management", https://learn.microsoft.com/en-us/azure/api-management/secure-mcp-servers

[^agentcore-gateway]: AWS, "Amazon Bedrock AgentCore Gateway", Amazon Bedrock AgentCore Developer Guide, https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway.html

## Frequently asked questions

### Should we let agents use servers listed in the public MCP Registry?

Use the registry to find servers, not to approve them. It is in preview, does not list private servers, delegates security scanning to package registries and other downstream services, and tells consumers to assume minimal-to-no moderation. Review a server you find there like any other third-party code, then add the version you approved to your own registry.

### Are local MCP servers safer than remote ones?

Not by default. A local server runs on the user's machine with the same privileges as the client that starts it, so a malicious or compromised package runs with that access. The MCP security guidance says clients must show the exact command before a one-click install of a local server, and should run the server in a sandbox with minimal default privileges.

### Should we ban MCP servers until the standard matures?

A blanket ban risks pushing use out of sight, and OWASP's MCP Top 10 lists unapproved deployments outside security governance, which it calls shadow MCP servers, as a risk in its own right. A more durable approach is to allow a short list of reviewed servers through managed settings or a gateway, block everything else, and widen the list as teams submit servers for review.

### How often should an approved MCP server be reviewed again?

Whenever its version, tools, tool descriptions or requested scopes change, and on a regular schedule otherwise. The joint guidance from the Five Eyes cyber security agencies recommends an allow list of tools and versions that are regularly verified as secure, so pin versions and treat each upgrade as a new approval. Patch quickly when an advisory affects a server or SDK you use.

Published November 16, 2026 by Sycamore.