Daniel Reyes, YuSMP Group
Daniel Reyes Principal Engineer (AI/ML), YuSMP Group · LLM systems, agents and AI tooling for US and EU products
Isometric diagram of many AI agent data streams flowing through a single secure gateway that checks identity, applies a policy shield and writes an audit log before allowing some streams through to enterprise data vaults and blocking one

The short answer

At Black Hat 2026 Snowflake launched the Cortex AI Gateway, a centralized layer that governs how AI agents access models, data, MCP servers and enterprise tools — enforcing identity, authorization, audit and cost limits on each tool call. It is built on technology from Snowflake's May 2026 acquisition of Natoma, covers third-party agents on Amazon Bedrock, Azure AI Foundry, ChatGPT, Cursor, LangChain and LlamaIndex as well as Snowflake's own, and shipped mostly in private preview with agent identity and restricted session scope generally available or close to it.

The signal for engineering leaders is bigger than one vendor. Alongside agent-identity acquisitions from Cyera and Okta in the same week, the launch shows the "MCP gateway" hardening from a niche security tool into standard infrastructure. If your roadmap has autonomous agents on it, a governance layer — who asked, what they can touch, was it allowed, what did it cost — is becoming a component you design in, not bolt on later.

What did Snowflake actually ship?

At the Black Hat 2026 security conference, Snowflake introduced the Cortex AI Gateway, described as a centralized control layer that governs how AI agents access models, data, MCP servers and enterprise tools. Crucially, it is not limited to Snowflake's own agents: it is built to govern third-party ecosystems too — Amazon Bedrock, Azure AI Foundry, ChatGPT, Claude Code, Cursor, and custom LangChain or LlamaIndex applications — from one place. The stated capabilities include fine-grained authorization and access control, real-time audit trails of agent actions, support for more than 100 MCP servers, automatic discovery and monitoring of "shadow AI," and cost routing with budget guardrails. Most features arrived in private preview, with agent identity and a restricted session scope listed as generally available or imminent.

The plumbing comes from an acquisition. Snowflake built the gateway on technology from Natoma, a centralized MCP-gateway startup it bought in May 2026, whose whole purpose was to enforce identity, policy and audit at the tool-call level. The framing from Snowflake's Chief Security and Trust Officer, Mayank Upadhyay, is the tell: “Enterprise AI is moving from data interoperability to agent interoperability, and security has to be at the center of that shift.” In other words, the hard problem is no longer getting systems to share data — it is getting autonomous agents to act across those systems safely. Anyone building serious AI agent systems recognizes that shift, because the moment an agent can do things rather than just answer questions, access control stops being a detail and becomes the whole game.

Why an agent needs a gateway at all

To see why this is more than product news, picture how most teams wire up their first agents. Each agent gets a set of credentials and connects directly to the tools it needs — a database, an internal API, a SaaS app, an MCP server or two. It works in a demo. It stops working as governance the moment you have a dozen agents, because every one of those direct connections is a separate path with its own keys, its own blast radius, and often no central log. Ask "which agent read that customer table last night, and was it allowed to?" and there is frequently no clean answer.

A gateway inverts that. Instead of agents holding credentials and calling tools directly, every call routes through one control point that checks three things on each request: who requested the action, what permissions they hold, and whether the action is allowed — then records it. That single choke point is what makes least-privilege access, clean revocation, real-time auditing and spend limits possible. It is also what surfaces shadow AI: unsanctioned agents and integrations someone stood up quietly, which you cannot govern because you cannot see them. The gateway pattern is deliberately the same idea the industry already accepts for APIs and identity — a policy-enforcing front door — applied to the new reality that the callers are now semi-autonomous agents, not human-driven apps.

Why this is a pattern, not a product

The reason to treat this as an architectural shift rather than a Snowflake headline is timing. The Cortex AI Gateway did not land alone: analysts noted a concentrated stretch of agent-identity dealmaking around the same window, including Cyera's roughly $1B acquisition of Oasis and Okta's acquisition of Permiso, with Snowflake fielding a roster of identity partners — 1Password, Aembit, Cyera, Okta, SailPoint, Saviynt and others — around its launch. When multiple large vendors move on the same capability in the same few days, it is usually because a category is crystallizing, not because one company had a clever idea.

What is crystallizing is the MCP gateway as a horizontal layer. A year ago, the Model Context Protocol was mostly discussed as a way to connect an agent to tools. The conversation has now moved one level up: given that agents will connect to many tools, who sits in the middle to enforce identity, policy, audit and cost? That middle layer is the gateway, and it is starting to look less like an optional security product and more like the equivalent of an API gateway or an identity provider — a piece of infrastructure you assume every serious agent deployment will have. That is why the lesson survives even if you never touch Snowflake: the shape of the stack is settling, and governance is being drawn as a first-class box in it.

What it means for US & EU software teams

The first implication is that agent governance is now a design-time concern, not a clean-up task. Retrofitting identity and audit onto agents that are already touching production data is painful and rarely complete. Teams that build the gateway pattern in early — scoped identity per agent, tool calls routed through one policy point, everything logged — get the governance almost for free; teams that defer it inherit an untraceable mesh of direct connections that is expensive to unwind.

The second is that this maps directly onto compliance obligations you already carry. A real-time, tool-call-level audit trail is precisely the evidence auditors want under SOC 2, and under the EU's DORA and the EU AI Act, where you increasingly must show who or what accessed data and whether the action was authorized. For regulated work in FinTech and HealthTech, an agent that can read regulated data without a governed, revocable identity is a control gap, not a convenience. The gateway is how you turn "our agents are governed" from an assertion into an artifact.

The third is a cost point that is easy to underrate: agents can spend money fast. An agent that retries, fans out sub-agents, or loops on a hard task can run up token and tool bills with no human in the approval path. Budget guardrails and cost routing at the gateway are the difference between catching that in an alert and finding it on an invoice. Whether you build your control layer in-house or buy one, the governance you want is the same: identity, policy, audit and spend limits, enforced in one place your platform and DevOps team actually owns.

What to do now

You do not need to adopt any specific gateway this quarter. You do need to stop treating agent governance as something you will "add later." Here is the shippable version.

  1. Inventory your agents and integrations. List every agent and tool connection in use, including unofficial ones — you cannot govern shadow AI you cannot see.
  2. Give every agent its own identity. Replace shared keys with scoped, least-privilege identities per agent, so access is attributable and revocable.
  3. Route tool calls through one control point. Even a thin internal gateway beats a dozen direct connections; make every action pass through a place that can allow, deny and log it.
  4. Turn on audit and treat it as compliance evidence. Keep tool-call-level logs and map them to your SOC 2, DORA and EU AI Act obligations now, not at audit time.
  5. Add spend guardrails. Set per-agent budgets and alerts so a looping or fan-out agent trips a limit instead of a surprise bill.
  6. Design it in for new projects. If you are early, put the governance layer in the architecture from the start; retrofitting it later costs far more.

None of this is a verdict on Cortex AI Gateway specifically; it is one strong implementation of a pattern that is quickly becoming standard. The durable takeaway is architectural: as agents move from answering to acting, the governed front door in front of them is turning into infrastructure — and the teams that draw it into the design now will spend far less proving control later.

Frequently asked questions

What is an MCP gateway?

An MCP gateway is a centralized control point that sits between AI agents and the models, data, tools and Model Context Protocol (MCP) servers they call. Instead of each agent connecting directly to every tool with its own credentials, calls route through the gateway, which enforces identity, authorization, policy and audit at the level of the individual tool call. It answers three questions for every action an agent takes: who requested it, what permissions they have, and whether the action is allowed. Snowflake's Cortex AI Gateway, launched at Black Hat 2026, is a prominent example built on technology from its acquisition of Natoma.

What did Snowflake announce at Black Hat 2026?

At Black Hat 2026 Snowflake launched the Cortex AI Gateway, a control layer that governs how AI agents access models, data, MCP servers and enterprise tools. It covers both Snowflake's own agents and third-party ecosystems such as Amazon Bedrock, Azure AI Foundry, ChatGPT, Claude Code, Cursor and custom LangChain or LlamaIndex apps. Capabilities include fine-grained authorization, real-time audit trails, support for more than 100 MCP servers, automatic discovery of shadow AI, and cost routing with budget guardrails. Most features shipped in private preview, with agent identity and restricted session scope generally available or arriving soon. The gateway is built on technology from Snowflake's May 2026 acquisition of the MCP-gateway startup Natoma.

Why do AI agents need a governance layer?

Because an autonomous agent does not just answer questions; it takes actions using real credentials, calling tools, reading data and triggering workflows across many systems. Without a central gateway, each agent-to-tool connection is a separate, often unlogged, path with its own permissions, which makes it impossible to answer who did what, hard to revoke access cleanly, and easy for unsanctioned shadow agents to appear. A governance gateway gives one place to enforce least-privilege access, keep a real-time audit trail at the tool-call level, cap runaway spend, and prove control to auditors under frameworks like SOC 2, DORA and the EU AI Act.

Does this only matter if we use Snowflake?

No. Snowflake's launch is the clearest single example, but the pattern is vendor-neutral. The same week saw agent-identity acquisitions from Cyera and Okta, and the gateway itself is designed to govern non-Snowflake agents built on Bedrock, Azure AI Foundry, ChatGPT, Cursor, LangChain and LlamaIndex. The takeaway is architectural: if you are building or buying agentic AI, an MCP-gateway-style governance layer — identity, policy, audit and cost control at the tool-call level — is becoming a standard component rather than an optional add-on, whichever platform you standardize on.

What should engineering teams do now?

Inventory the agents and tool integrations you already run, including unofficial ones, since you cannot govern what you cannot see. Give each agent its own scoped identity and least-privilege permissions instead of shared keys, and route tool calls through a single gateway so every action is logged and revocable. Add budget guardrails to catch runaway agent spend early, and treat the audit trail as a compliance artifact for SOC 2, DORA and the EU AI Act. If you are early, design the governance layer in from the start rather than retrofitting it after agents are already touching production data.

Sources

Snowflake — Enterprise AI security and agentic MCP governance with Cortex AI Gateway
VentureBeat — Snowflake launches Cortex AI Gateway to control AI agents and prevent runaway enterprise costs
Yahoo Tech — Snowflake's Cortex AI Gateway signals MCP gateways are crystallizing as infrastructure
Cybersecurity Magazine — Snowflake launches Cortex AI Gateway to govern agentic AI