/aienm.

Why Runtime Permission Checks Beat Agent-Layer Policy Rewrites for Access Governance

Checking permissions at runtime keeps agents inside real access rules.

· 8 min read
Cover illustration for “Why Runtime Permission Checks Beat Agent-Layer Policy Rewrites for Access Governance”
Enterprise AI Governance · November 18, 2026 · 8 min read · 1,845 words

With automatic permission inheritance across enterprise AI data sources, each agent action is checked against the access state in the systems that own it. Runtime permission checks beat agent-layer policy rewrites by using those permissions directly and eliminating the work of maintaining a separate copy in prompts. A governed MCP gateway and registry bring that control to other agent surfaces without having to rebuild access rules for each AI tool.

Why the MCP governance problem is really an access-state problem

MCP solves the N×M problem of custom connections between agents and enterprise systems by giving them a shared protocol layer. That simplifies integration, but it also concentrates risk. MCP servers can aggregate credentials for multiple enterprise systems behind a single connection point, so one compromised or misconfigured server can affect everything it touches.

Anthropic open-sourced MCP in November 2024, and the protocol moved to the Agentic AI Foundation under the Linux Foundation in December 2025. That shift puts MCP beyond the scope of a single vendor feature. It is shared enterprise infrastructure. MCP implementations now give agents access to business systems through enforceable controls or through connections that merely work.

The protocol does not settle that choice. An MCP server can have enterprise-grade access controls, audit logs, and compliance enforcement, or it can have none of them. For identity and access management teams, the difficulty is that MCP brings authentication, consent, session state, and tool invocation into the same workflow. Controls built for static clients and approvals at a human pace may fail to control an agent that chooses its next action as it runs. Connection approval and whose access state governs each action through it therefore both need scrutiny.

What agent-layer policy rewrites actually do — and why reconstruction is the wrong model

With an agent-layer policy rewrite, access rules go into the agent’s prompt or system instructions. The agent then has to infer what a user may see or do from text outside the systems that manage those permissions. This makes the model the enforcement point. It must interpret both the task and the rules limiting the task, rather than have an external control decide whether an operation is allowed.

Source systems already have the access state that is needed. Identity providers, SaaS platforms, and databases update it through HR events, role changes, and security reviews. A prompt containing a version of those rules is a snapshot, and it begins aging as soon as it is written. For each agent that uses it, there is more work to keep it up to date.

A login check cannot fully govern tools and data paths that an agent selects later, because the relevant privileges become clear during action. At the same time, user-supplied input can confuse or bypass rules in the model’s context in ways it cannot with an external authorization layer. Instructions are not an access boundary. When the agent has broad service-account access behind those instructions, the source system may allow an operation even when the prompt tells the agent to refuse it.

What overprivilege and prompt-injectable policy look like when they fail in production

The Cursor AI incident shows how that mismatch becomes a breach. An agent with privileged service-role database access was working through customer support tickets that had user-supplied text in them. Attackers put natural-language prompt injection instructions into that text. Those instructions told the agent to read sensitive integration tokens and share them in a public support thread.

The injected text did not create the database privilege. The agent already had it. Its service account provided broad access regardless of which user triggered the workflow, and no mechanism limited its reads to what that user was entitled to see. The workflow also lacked per-operation logging and a boundary separating untrusted input from executable instruction. The combination let ticket content redirect capabilities that should not have been available to that request.

The original MCP specification had no granular authorization model to deal with this kind of problem. It had no mandatory authentication requirement for server connections and no mechanism for per-operation permission scoping. That absence left implementers responsible for the boundary. A connection alone was not evidence of suitable authorization. The incident exposes the precise point where a runtime check belongs, before an agent can use its connection to perform a read the requesting user is not allowed to make.

How do AI agents respect existing access controls without reconfiguring everything?

Runtime permission checks put the decision at the moment of each tool invocation. The runtime identifies the agent, user, session, environment, and target, then checks tool permission, parameters, data scope, time, rate, and potential impact before allowing execution. The model proposes an action, but does not authorize it. Because the enforcement layer sits outside the model’s context, user-supplied text cannot rewrite its decision.

A gateway makes that boundary concrete. MCP clients point to a single gateway URL rather than directly to individual servers, and the gateway routes calls to the appropriate backend. It handles OAuth 2.1 token issuance and validation, enforces per-team and per-role tool access, and records each invocation with user identity and timestamp. It also applies data loss prevention rules to tool inputs and outputs. These controls govern the call itself.

When authorization is checked against live identity-provider state, a role change immediately changes what the agent can do without a prompt update or a separately synchronized policy document. A user’s team membership comes from groups and roles and sets which MCP servers they can connect to, while token-scoped authorization lets business units have their own policies. Denial happens before execution. The boundary enforces least privilege, so it does not depend on the agent holding itself back.

That control has a performance cost. A gateway adds a network hop to every tool call, so runtime governance is not free of latency. The practical response is to deploy the gateway close to agents and optimize it for streaming and batching. Removing the check avoids the hop, but also removes the point where current permissions can stop an unauthorized operation.

What Enterprise-Managed Authorization establishes — and where it still leaves a gap

The Enterprise-Managed Authorization extension became stable on June 18, 2026, removing a barrier to using MCP in the enterprise. EMA lets administrators control server access through a trusted identity provider, while employees authenticate with their existing enterprise identity. Administrators enable a server once, and users receive access scoped to their groups and roles. Repeated per-server consent screens are removed. The extension also removes the interactive account-selection step that can mix personal and enterprise accounts.

Technically, the client obtains an Identity Assertion JWT Authorization Grant during single sign-on and exchanges it for an access token from the MCP server’s authorization server. Access decisions are made in the identity-provider admin console, which has one trail that can be audited across connectors. Okta was the first supported identity provider, using its Cross App Access implementation of ID-JAG. Anthropic implemented EMA across Claude, Claude Code, and Cowork, while Visual Studio Code added support in the IDE. These implementations address the connection-governance part of the runtime control stack.

The distinction is important when comparing capabilities. EMA decides whether a user can connect a client to a server and at what scope, but it does not inspect MCP traffic after token issuance. Connection approval is not per-action authorization. Gateway controls are still needed to govern what happens inside the session. As MCP adds async tasks, elicitation, and multi-server workflows, task-bound authorization also narrows what a compromised session can reach compared with a reusable identity artifact.

Why a governed registry is what prevents runtime controls from fragmenting as agents scale

A gateway can enforce only the calls that pass through it. If teams connect unapproved servers directly, those connections bypass its controls and recreate the fragmentation MCP was meant to reduce. The public MCP server registry grew to over 10,000 active public servers by March 2026. Availability is not approval. Connecting every server that is available can increase both the token budget and the attack surface instead of giving an agent a limited set of tools it can use.

A governed private registry limits that expansion. The platform team controls what is listed, each server has a designated owner and review cycle, and version approval and deprecation are built into its lifecycle. With role-scoped access, teams can find and reuse approved servers, saving the work of building the same connections again. A shared directory cannot provide that control by itself. The registry governs which servers enter the environment, while the gateway governs what agents may do through them.

Teams should publish an internal catalog once a pilot proves its value, with ownership and review attached to every server. When teams plan upgrades around deprecation windows, changes to the specification do not catch them by surprise. Domain experts should own their team’s AI skills and context, and the registry should show who owns them and keep track of versions. This lets central IT avoid having to approve each action on its own. Runtime checks inherit authoritative access state at the call level, but a governed inventory is what keeps teams from creating unchecked routes around them.

How consistent runtime governance enables one set of permissions to travel across every agent surface

The same separation removes the need to rebuild governance for every AI surface. A skill or integration built for Claude Desktop that must be manually reimplemented for ChatGPT, Cursor, and Slack creates duplicate work and separately maintained policies. Each copy becomes another place for access rules to diverge. With the registry-and-gateway model, each team instead receives a scoped MCP endpoint, with runtime enforcement and versioned context behind it. The client is no longer the home of the access policy.

Slack’s MCP server illustrates the common connection model. Slack lists Claude.ai, Claude Code, Perplexity, and Cursor as partner clients in its official documentation. Access controls apply across supported surfaces, with requests from each client governed by the same controls. That is different from claiming that every client supports every server. Shared authorization still depends on what the connections allow and what controls they can enforce.

Salesforce’s Hosted MCP Servers illustrate the same principle at the data layer. Generally available from April 29, 2026 for Enterprise Edition and above, they let an AI client query and act on CRM data while Salesforce handles hosting, authentication, and permissions. The useful boundary limits access to a small set of approved tools. Salesforce’s source-side permissions, Okta’s identity role in EMA, and a gateway’s per-call enforcement therefore answer different evaluation questions. They are complementary capabilities, each providing part of the architecture.

With this division, business context and permissions stay with the organization as it uses multiple models, independent of any particular LLM. It also makes enforcement inspectable. The gateway logs every tool invocation with user identity and timestamp, the registry keeps track of who owns each server and which versions are approved, and EMA keeps the connection-authorization trail. Together, those records let access decisions be traced across surfaces. Trust at scale rests on evidence of what was permitted and executed.

Sources

  1. Enterprise-Managed Authorization: Zero-touch OAuth for MCP

More in Enterprise AI Governance