How Enterprise AI Permissions Should Actually Work
Enterprise AI agents need permission models built for reasoning, not static credentials.

AI agents reason at runtime. They decide which tools to call, which systems to touch, and what to do next, without a person approving each step. The enterprise permission model was never built for that kind of decision-maker, and that mismatch is why so many agentic AI deployments stall before they reach production.
Why the current permission model breaks for reasoning agents
A traditional service account does what it was coded to do. Its risk is bounded by its code. An AI agent works differently: it reasons about a goal, chains tool calls together, and decides on its own which systems to access and in what order, with no human checking each step along the way.
That difference matters because permission systems are built around predictability. A static credential assigned to a script carries a fixed, knowable scope. The same credential assigned to an agent carries a scope defined by whatever the agent can discover and attempt during reasoning, which is a much larger and much less predictable space. An overprivileged credential sitting in a service account is a liability. The agent can chain unexpected tool calls together, so the same credential becomes far riskier behind it, because the agent can find paths through that permission that no one anticipated.
The scale of this shift is already visible in the numbers. Non-human identities now outnumber human identities in enterprise environments by 45 to 1 on average, and that ratio keeps climbing as more agents get deployed. Identity and access management systems, meanwhile, were built for human login flows, where a person sits at the keyboard, authenticates once, and acts within a session. Agents don't log in and sit still. They act continuously, across many tool calls, often with no session boundary that maps cleanly onto how IAM was designed to work.
The obvious objection is that agents are just another kind of service account, so they should be governed the same way service accounts always have been. That argument falls apart on one point: a service account cannot decide, mid-task, to call a tool it was never configured to use. An agent can. That capacity to improvise its own path through a system is precisely what the static permission model has no answer for.
What the adoption-governance gap looks like in practice
The gap between agent adoption and agent governance is already measurable, not theoretical. The Model Context Protocol, the open standard that lets AI agents discover and call external tools, has reached hundreds of millions of monthly downloads, and a large share of technical leaders report that it's running in production. Yet only a minority of enterprise agentic AI pilots actually make it to production. Most stall on gaps in identity, audit, and access control.
That stall is a governance problem that appears after the pilot works technically, when security and compliance teams start asking who approved what an agent can touch, and nobody has a clean answer.
The stakes keep rising because MCP is no longer one vendor's experiment. It was donated to the Linux Foundation's Agentic AI Foundation in December 2025, backed by OpenAI, Google, Microsoft, AWS, Cloudflare, and Bloomberg. So the governance decisions being made about MCP right now will shape how every one of those platforms handles agent permissions going forward.
Internal readiness lags just as far behind. Only a small fraction of organizations have a formal, enterprise-wide strategy for agent identity, and fewer still say they feel highly confident their IAM systems can handle agent identities at all. That's the gap this piece is built around: real adoption, thin governance, and a widening distance between the two.
The four failure modes that let agents exceed their intended permissions

Most permission failures in agentic deployments trace back to four specific mechanisms, and each one exploits a blind spot the static permission model was never designed to catch.
The first is overprivileged credentials stored in plaintext. Many MCP servers get deployed with no authentication at all, and the API keys that should protect them sit exposed in plaintext config files. An agent connected to that server inherits whatever the credential allows, whether or not the task in front of it calls for that much access. Trend Micro found 492 MCP servers exposed to the internet with zero authentication, and Datadog's research found audits turning up thousands of exposed API keys and passwords tied to insecure MCP credential handling.
The second is tool poisoning through metadata manipulation. An MCP tool's name and the summary a user sees stay exactly the same, but the natural-language description the agent actually reads, the text it uses to decide how and when to call the tool, gets silently altered. Because MCP reflects metadata updates dynamically, a server with no re-approval workflow lets that poisoned description go live in production with no additional review. The trust boundary that matters here sits between systems, not inside any single one of them: MCP blends instructions and data together, so changing a tool's metadata redirects an agent's behavior just as effectively as rewriting its system prompt would.
The third is the confused deputy attack, where an MCP server executes actions using its own elevated privileges instead of the privileges of the person who made the request. A user without database admin rights asks an agent to run a query, and the server simply complies, because it happens to have admin access. The server was handed more authority than the principal it was supposed to be serving on behalf of, and per-user, per-action scoping is meant to close that structural gap.
The fourth is cascading injection across multi-agent workflows. When agents chain together, one agent's output becomes the next agent's input, so malicious content embedded anywhere in that chain can propagate forward, redirecting behavior, triggering unauthorized data access, or hijacking control flow entirely. The NSA's report on MCP security design considerations found that some implementations let malicious, actor-controlled inputs reach execution environments without proper constraints, and that produces vulnerabilities generally rated high severity. Across assessed MCP instances, command injection affects a large share of tested servers, and path traversal affects an even larger share.
What named incidents show about real-world consequences
Each of these four failure modes has already produced a documented incident, and the pattern repeats: a permission gap that looked manageable on paper turned into a critical incident the moment an agent was actually running the show.
Anthropic's own Git MCP Server was the subject of one such case in January 2026. Researcher Yarden Porat of Cyata published an exploit chain built from three CVEs: an unrestricted git_init function (CVE-2025-68143), an argument injection flaw (CVE-2025-68144), and a path traversal bug that bypassed repository scoping (CVE-2025-68145). Chaining the Git MCP server together with the Filesystem MCP server, the exploit achieved remote code execution through prompt injection alone. Anthropic patched the issue in mcp-server-git version 2025.12.18 and later.
In April 2026, an authentication bypass in the Azure DevOps MCP server, tracked as CVE-2026-32211 and scored 9.1 on the CVSS scale, left API keys and tokens accessible without any credentials required. No patch was available at the time; Microsoft published mitigation guidance instead.
That same month, OX Security published research titled "The Mother of All AI Supply Chains," identifying a command execution vulnerability across Anthropic's official MCP SDKs for Python, TypeScript, Java, and Rust. The flaw sits in the STDIO transport, which passes incoming configuration parameters directly to the host operating system's shell without sanitizing them first, a design choice that touches a wide supply chain of package downloads.
In June 2026, Tenet Security disclosed an "agentjacking" technique built on Sentry's MCP event injection, finding injectable DSNs across 2,388 organizations and a high rate of successful agent execution in testing. Sentry declined to remediate the underlying design and instead deployed a filter on payload strings, so the architectural risk stayed in place.
What ties these four incidents together is not their severity scores. Each one exploited a permission gap that the static model was structurally unable to detect, whether because a credential was simply too broad for the task at hand, or because no trust boundary was ever enforced at the level of the individual tool call. No vault was broken into. The access was already there, waiting to be used.
What an identity-first permission model requires
If you fix enterprise AI permissions, you replace static role assignments with a model where every agent carries a verifiable identity, every credential is scoped to the exact action being performed, and enforcement happens at the depth of the individual tool call, not at the moment of deployment.
That starts with extending identity infrastructure that already exists for people. The SSO and SCIM protocols that manage human users need to apply to agents too, so identity ties to every action an agent takes, not just to the login session it started with.
Credentials need to move to a just-in-time model. Instead of issuing an agent a long-lived token valid for every tool its server exposes, the agent should receive a credential scoped only to the specific action it's about to perform. If an agent has unrestricted tool access, it functions like a service account running with domain admin rights, and Practical DevSecOps found that 47 to 53 percent of organizations have already seen AI agents exceed their permissions or cause an incident as a result. That range shows how fast a single misconfiguration can turn into a real-world failure. You need to register every tool an agent might call, scope it to a defined purpose, and risk-rate it before the agent is ever allowed to invoke it.
Authorization itself needs to shift from a question about identity to a question about intent. The old question asked whether an identity has access to a system; the new one asks whether this specific agent, acting on behalf of this specific user, should be allowed to take this specific action right now. A refund agent, for example, might be allowed to issue refunds automatically up to a defined dollar threshold, required to flag anything above that threshold for a human to review, and limited to payouts it was actually asked about. The scope follows what the agent is actually trying to do at the moment it acts, rather than a role it was assigned once at setup. High-risk actions, like writes to customer records, outbound communications, code deployments, or changes to financial data, need explicit sign-off from a named approver, with every rejected action logged along with the reason it was rejected and no quiet auto-approval after some timeout period.
Tool registration itself needs a re-approval step built in. Because a tool's metadata can redirect an agent's behavior just as powerfully as a change to its system prompt, any update to a registered tool's description should require human review before that change goes live. Microsoft Incident Response documented exactly this pattern against a financial operations Copilot Studio agent, where an attacker silently modified a third-party tool description to direct the agent to retrieve unpaid invoices and attach them as a parameter in an enrichment call, and the update went live with no security review triggered. That single requirement closes off the tool poisoning vector directly, because it forces review of the actual text an agent reads, not just the tool's visible name. An MCP registry that tracks inventory, manages approval workflows, and keeps version history is the operational backbone that makes this kind of per-tool governance workable at enterprise scale.
None of this matters without an audit trail that captures what actually happened. Logs need to record individual tool invocations, the permissions granted for each one, the data touched, and the outcome produced, going beyond a summary of the session the agent ran in. The liability sits in the specific action an agent took during the broader session.
Runlayer builds this model into its platform directly: just-in-time credentials, built-in OAuth and credential handling, SSO and SCIM identity tied to every action an agent takes, policy enforcement at tool-call depth, and real-time detection for tool poisoning and prompt injection. The goal of that kind of architecture is making the secure way to deploy an agent the same path a platform team would take anyway, rather than an extra burden layered on top of getting something shipped.
Regulatory enforcement and the permission model as a compliance question
The EU AI Act's enforcement phases and the first wave of agentic-specific governance frameworks have turned the permission architecture described above into a compliance requirement, and not just a security best practice. Regulators are no longer asking only whether a company has a security policy on paper. They're asking whether an organization can show, action by action, who an agent was acting for, what it was authorized to do, and what it actually did.
That shift raises the cost of treating permissions as something to bolt on after a pilot succeeds. An audit trail built only at the session level, or a registry with no re-approval workflow for tool updates, won't satisfy a regulator asking for proof that a specific high-risk action was authorized by a named approver before it happened. The identity-first model is becoming the only way to deploy agents that holds up under the kind of scrutiny the EU AI Act and the governance frameworks following it are starting to apply.
Sources
- Securing AI agents: When AI tools move from reading to acting
- AI Agent Security Risks 2026: MCP, OpenClaw & Supply Chain
- The Enterprise MCP Guide 2026 - The Agentics
- Model Context Protocol (MCP): Security Design ...
- MCP Security Statistics 2026: CVEs, Vulnerabilities & Breach Data - Practical DevSecOps
- MCP Security Risks in 2026 and Registry Controls
- Enterprises are racing to secure agentic AI deployments - Help Net Security


