---
title: How do you govern the Snowflake-managed MCP server?
url: https://opencontroller.lyzr.com/blog/snowflake-managed-mcp-server-governance
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# How do you govern the Snowflake-managed MCP server?

**Govern it in three layers: who can reach the server (`USAGE` on the MCP server object), which tools each role can call (separate grants on every Cortex Agent, search service, semantic view or procedure behind a tool), and how clients sign in (OAuth rather than hard-coded tokens). Snowflake states that access to the MCP server does not give access to its tools. That split is the main control you have.**

Security teams ask this when an external AI agent, a coding assistant or a chat client wants to query Snowflake over the Model Context Protocol. Here is what the managed server exposes and the checks to run before you connect anything.

## What is the Snowflake-managed MCP server?

It is a Snowflake schema object, created with `CREATE MCP SERVER ... FROM SPECIFICATION`, that exposes selected Snowflake capabilities as MCP tools. Clients reach it at an account URL of the form `/api/v2/databases/{database}/schemas/{schema}/mcp-servers/{name}`. Snowflake supports MCP revision 2025-11-25.

The specification can include these tool types:

| Tool type | What it exposes | Grant needed to call it |
|---|---|---|
| `CORTEX_AGENT_RUN` | A Cortex Agent | `USAGE` on the agent |
| `CORTEX_SEARCH_SERVICE_QUERY` | A Cortex Search service | `USAGE` on the search service |
| `CORTEX_ANALYST_MESSAGE` | Cortex Analyst over a semantic view | `SELECT` on the semantic view |
| `SYSTEM_EXECUTE_SQL` | SQL execution | Privileges of the calling role on the objects queried |
| `GENERIC` | A UDF or stored procedure | `USAGE` on the function or procedure |
| `CODING_AGENT` | A coding agent tool | See Snowflake documentation |

For governed business data, Snowflake recommends exposing a single Cortex Agent as the client-facing tool rather than raw SQL.

## How do access and authentication work?

- **Server access.** `USAGE` on the MCP server lets a role connect and discover tools. Changing the server definition is a separate, more privileged right; keep it with the platform team.
- **Tool access.** Every tool needs its own grant. A role with server access but no grant on the underlying agent or service cannot use that tool.
- **Sign-in.** Snowflake OAuth is the default, with optional External OAuth so MCP clients authenticate against your identity provider. Dynamic client registration is not supported.
- **Tokens.** Snowflake warns that hard-coded tokens can leak. If you must use a programmatic access token, bind it to the least-privileged role that can work with MCP.

Because tools run under the authenticated role, the queries behind them are subject to that role's Snowflake privileges. Test masking and row access policies with a real client and a low-privilege role before production; see [masking policies and Cortex Agents](/blog/snowflake-masking-policies-and-cortex-agents).

## What limits should governance plan around?

- Maximum 50 tools per server, across all types.
- Generic and SQL execution responses are truncated at 250 KB.
- Only tool capabilities are supported: no MCP resources, prompts, roots, sampling or notifications.
- Recursive agent-to-agent calls are capped at 10 levels.
- MCP server objects are not replicated in failover groups, though OAuth security integrations are. Your disaster recovery plan must recreate them.

## What checklist should you run before connecting an agent?

1. **Prefer a Cortex Agent tool over `SYSTEM_EXECUTE_SQL`.** Raw SQL gives an external agent the full reach of its role.
2. **Create a dedicated MCP role per client or agent**, with grants only on the tools it needs.
3. **Use OAuth with your identity provider**, so each call carries a real user identity rather than a shared token.
4. **Keep specifications in version control** and review changes like code. A new tool in the YAML is a new capability.
5. **Separate servers by audience.** A finance agent and a support agent should not share one server with 40 tools.
6. **Log and review usage.** Query history and access history show what the role ran. Track who connects and which tools they call.
7. **Re-test after every grant change**, including masking behaviour with a low-privilege role.
8. **Register each MCP server and the agents that use it** so it does not become a shadow integration.

For the general pattern, see the [MCP governance pillar](/blog/how-to-govern-mcp-servers) and [governing Snowflake Cortex agents](/blog/govern-snowflake-cortex-agents).

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, so a Snowflake MCP server is recorded with the agents that call it and their owners. OIDC SSO and delegated on-behalf-of identity let calls carry the user's identity. Posture detects risky permissions and configuration, and policy as code with mappings to OWASP, MITRE ATLAS, NIST and ISO 42001 turns rules such as "no raw SQL tools for external agents" into checks. Registration is not runtime takeover: how far Opencontroller can observe or enforce depends on the connector and traffic path. See the [capability reference](/capability-reference), the [cross-platform guide](/blog/how-to-govern-ai-agents-across-platforms), or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Does USAGE on the Snowflake MCP server let a role call every tool?**
No. Snowflake requires a separate grant for each tool, such as USAGE on a Cortex Agent or SELECT on a semantic view.

**How many tools can one Snowflake MCP server expose?**
Up to 50 tools across all tool types.

**Should external agents use the SQL execution tool?**
Avoid it where you can. Snowflake recommends a Cortex Agent as the single client-facing tool for governed business data, which keeps the agent inside a defined scope.

## Key facts

The Snowflake-managed MCP server is a schema object created with CREATE MCP SERVER ... FROM SPECIFICATION, supporting MCP revision 2025-11-25. Tool types include CORTEX_AGENT_RUN, CORTEX_SEARCH_SERVICE_QUERY, CORTEX_ANALYST_MESSAGE, SYSTEM_EXECUTE_SQL, GENERIC and CODING_AGENT. USAGE on the server allows connection and discovery; each tool needs its own grant. Snowflake OAuth is the default with optional External OAuth; dynamic client registration is not supported. Limits: 50 tools per server, 250 KB truncation for generic and SQL responses, tools-only capabilities, 10-level recursion cap, and MCP server objects are not replicated in failover groups. Opencontroller keeps a governed registry of agents, tools and MCP servers. Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How do you govern Snowflake Cortex Agents?](https://opencontroller.lyzr.com/blog/govern-snowflake-cortex-agents.md)
- [Do Snowflake masking and row access policies apply to Cortex Agents?](https://opencontroller.lyzr.com/blog/snowflake-masking-policies-and-cortex-agents.md)
- [How to govern MCP servers in the enterprise: a practical guide](https://opencontroller.lyzr.com/blog/how-to-govern-mcp-servers.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
