CISO Playbook for Governing Internal vs External AI Agents
Security teams need separate playbooks for internal shadow agents and external tool-poisoning risks.

AI agents need two different governance models, not one. Internal agents and external agents carry different identity setups, different threat patterns, and different controls, and a single blanket policy will leave gaps on both sides. Internal agents typically run on credentials inherited from the developers who built them, often riding admin-scoped service accounts with far more reach than the task requires. But external agents carry all of that risk plus the exposure that comes from MCP tool ecosystems, third-party integrations, and data flows that cross organizational boundaries.
A security team that only watches for outside attackers misses the agents employees spun up on their own, quietly, with no review. A security team that writes policy documents but skips runtime controls stays open to manipulation from outside actors no matter how thorough the paperwork looks. A large share of enterprises already run AI agents or workflows their security teams never approved and don't know exist, and that specific risk, the shadow agent, is an internal problem rather than an external one.
Part of why this split matters so much comes down to the protocol most agents run on. MCP, which Anthropic open-sourced in 2024, was not built with authentication and authorization baked in. The NSA noted that the protocol doesn't define how a session gets tied to an identity, and that MCP still has no way to exchange role-based access control permissions when a session starts. Governance can't be handed off to the protocol itself because the protocol doesn't make those decisions. It has to be built on top of MCP, and built differently depending on which side of the perimeter the agent sits on.
Internal agent governance: shadow agents, credential sprawl, and inherited privilege
Internal agents cause damage mainly through bad provisioning, not outside attack, getting set up with too much access while nobody on the security team knows they're running.
Shadow AI sits at the center of this. Low-code and no-code platforms make it simple for employees to build and launch agents without any official sign-off, and every one of those agents becomes a blind spot for monitoring, patching, and threat detection. Active agents inside the Microsoft 365 ecosystem have grown at a pace that has outrun the governance frameworks built for supervised AI tools, leaving security teams managing a population of agents larger than what their processes were designed to handle.
Credential sprawl compounds the visibility gap. A single MCP server can hold credentials for Slack, GitHub, Postgres, and Salesforce all at once. Compromise that one server and four separate systems go down with it. Each new integration an agent connects to needs its own authentication, so credentials multiply fast, and hardcoded secrets end up scattered across agent configurations, environment variables, and orchestration frameworks. Research on the MCP registry found that only a small fraction of servers use OAuth. The rest depend on static API keys sitting in environment files, unscoped, with no time limits and no rotation schedule.
Inherited privilege rounds out the internal failure pattern. An agent should never borrow a developer's login or share one credential across an entire platform, but that's how most of them get built. The Supabase incident shows what that costs in practice: an agent running under privileged service-role access processed input an attacker controlled, and that access let the attacker reach further than intended. An agent scoped to read-only access on support data would not have carried the credentials needed to exfiltrate integration tokens.
Among large-enterprise security leaders surveyed, a large majority report they lack full visibility into their own AI identities, and most enforce no access policies for those identities. Meanwhile those same AI systems have access to core business platforms, including ERP, CRM, and financial systems.
External agent governance: tool poisoning, rug pulls, and supply chain exposure
External agents break down at a different point: the trust boundary between the agent and whatever tool it connects to. MCP standardizes that boundary without securing it, so the standardization itself becomes part of the exposure.
Tool poisoning is the sharpest version of this. An agent reads a tool's description with the same trust it extends to its own system prompt, so a malicious server can bury commands inside that description and get the model to read files, leak secrets, and still hand back an answer that looks completely normal. The MCPTox benchmark tested this directly, building adversarial versions of real tools pulled from live MCP servers and running them against major language models. The average attack success rate was high across the board, and the highest rate hit a leading reasoning model. The more capable models often did worse here, because their stronger instruction-following made them more likely to comply with the malicious metadata rather than question it.
Microsoft's Defender research team disclosed a real-world case that follows the same pattern. A finance team's agent connected to a third-party invoice enrichment tool that had been approved once but never reviewed again. The attacker later updated the tool's description while keeping its visible name unchanged, and MCP picked up that change automatically, with no trigger that forced re-approval. The tool kept running under the same name the finance team had signed off on, except now it did something else.
Rug pulls work the same trust gap from a different angle: a server behaves exactly as expected at install time, then quietly changes its behavior once permissions are already granted. MCP servers can update their own tool definitions without alerting the client, and most clients never flag the change. You review tool definitions once, at the moment of connection, but tool responses keep flowing into the agent's context continuously, without anywhere near the same scrutiny.
Supply chain attacks push the exposure past any single tool. A legitimate MCP server with a large install base gets compromised through a dependency update or a hijacked maintainer account, and every organization running that server inherits the backdoor automatically. Wiz Research disclosed one such case: a high-severity flaw in the Amazon Q VS Code extension, tracked as CVE-2026-12957, let a malicious repository achieve arbitrary code execution and steal cloud credentials through a crafted workspace MCP configuration file. A second flaw, CVE-2026-12958, addressed a related symlink-handling issue. The MCP server processes spawned in that attack inherited the developer's full environment. In January 2026, researchers found over 42,000 OpenClaw AI agent instances exposed on the open internet, leaking API keys, Slack credentials, and chat histories through MCP endpoints that had no authentication.
Data residency belongs in this list too, separate from any particular vendor's security posture. When an agent's tool discovery and MCP interactions route through a third-party cloud, sensitive information leaves the network boundary on every single interaction. For organizations with HIPAA, GDPR, or financial services data residency obligations, that routing pattern is a compliance problem regardless of how well the vendor on the other end secures its own infrastructure.
The MCP 2026-07-28 specification update and the external threat surface for enterprises
MCP's move toward enterprise scale shifts security responsibility off the protocol and onto whoever operates the server. That shift means any external governance framework built on the older version of MCP is already out of date.
The new specification adds MCP-specific HTTP headers, MCP-Method and MCP-Name, and those headers open two new paths for attack. Systems that misinterpret header values create a protocol confusion risk, and if API keys, tokens, or personal data end up inside those headers, they become visible to load balancers, logging systems, and any other intermediary sitting between the agent and the server.
MCP Apps now stand as a first-class extension within the formal Extensions framework, and that brings traditional web vulnerabilities into an environment that wasn't built to handle them, stored cross-site scripting among them. Long-running tasks add a denial-of-service path: an attacker can kick off an expensive operation and disconnect, leaving the server stuck holding resources it can't reclaim.
Akamai's Maxim Zavodchik, senior director of threat research, summed up what this means for defenders: the expanded attack surface now depends heavily on how individual developers implement the new specification. Security boundaries the protocol used to enforce on its own now sit with server operators instead, and that handoff raises the odds of implementation mistakes creeping into production. Enterprises got a 12-month window from the specification's finalization on July 28, 2026 to adjust their external governance frameworks to the new threat model the update introduced.
The agent identity architecture that both frameworks depend on
Both frameworks start from the same premise: an AI agent is a non-human privileged identity, not an application and not a standard service account. That classification is the prerequisite everything else gets built on.
Traditional service accounts are deterministic, narrow, and governed by fixed rules. AI agents break that mold on every dimension: they adapt their behavior, they can operate across a broad scope, they make autonomous decisions, and they read context before acting. That combination makes agentic AI security a harder problem than traditional machine identity governance, and treating an agent like a glorified service account misses what makes it dangerous.
Every production agent needs its own identity record, distinct from any other system's. That record should include a unique identifier, a named owner (business or technical), an approved purpose, a defined trust level, a documented lifecycle state, and full detail on its credentials and when they expire. The authentication stack the field is converging on for 2026 pairs OAuth 2.1 with PKCE for browser-based agents, JWT bearer assertions for service-to-service flows, and signed agent identity tokens that carry the full delegation chain from one end to the other.
Short-lived, task-scoped credentials put least privilege into practice. Access should expire the moment the workflow finishes, the user cancels the request, an approval window closes, the agent's risk level shifts, or the original business purpose no longer applies. None of this works without a central point of visibility. A centralized MCP gateway gives security teams one inventory covering every server, skill, and agent in the environment, and without that single inventory, neither the internal nor the external governance framework has anything real to enforce against. Platforms like Runlayer, which combine an AI control plane with MCP gateway functions, are built around that exact gap, tying identity to every agent session and enforcing policy at the tool-call level where the protocol stays silent.
The internal governance framework: discovery, classification, and runtime enforcement for agents inside the perimeter
Internal governance has to start with discovery, because an agent nobody has found is an agent nobody can govern, and most enterprises haven't found most of theirs yet.
The first concrete step is a full inventory of every MCP server running across the environment. Each one gets classified as local or remote, and anything unvetted or no longer in active use gets removed or isolated. Shadow agent detection works best when agents get treated like any other unmanaged endpoint: an agent launched from Slack, a low-code platform, or a developer's own environment needs the same visibility that endpoint detection already gives to unmanaged devices on the network.
Classification comes next, once discovery identifies what's actually running. Each agent should get assessed against a risk tier based on the sensitivity of the data it can touch, how broad its permissions are, which identity it operates under, and whether it has a named owner. Access scoping is the single highest-leverage control available here. The Supabase case proves the point directly: an agent scoped to read-only access on support data would not have carried the credentials needed to exfiltrate integration tokens. Cutting privilege down to what a task actually requires isn't a performance tradeoff. It shrinks the blast radius if something goes wrong.
Credential rotation and lifecycle management need enforcement in practice. When a developer leaves the company, their MCP credentials should not keep working. Agents should run on short-lived credentials tied to the task at hand, not standing API keys left sitting in environment files indefinitely. Internal policy should mandate tool allowlists for each agent, require re-approval whenever a tool's definition changes, and tie agent identities to centralized identity and access provisioning so they get deprovisioned automatically along with the employee lifecycle they're attached to.
Runtime enforcement matters as much as any of the policy work. Monitoring needs to happen at tool-call depth. An agent that suddenly calls a tool outside its approved purpose is a detection signal worth acting on immediately.
The external governance framework: tool vetting, supply chain controls, and cross-boundary data governance
External governance is a trust problem at its core. Every third-party MCP server an agent connects to represents a trust decision, and most organizations are making that decision by default rather than by design.
You need an approved server registry before any external MCP connection reaches production. Unknown servers should be blocked by default, with approval as the exception rather than the starting assumption. A registry gives a team inventory, an approval workflow, and version history to work from, but it doesn't replace identity and access management, network controls, or runtime enforcement. It's the starting point for governance, not the whole system.
Tool definition monitoring has to run continuously rather than once at install time. The Microsoft Defender case showed how a tool approved at installation can turn malicious later through a silent description update, with no mechanism catching the change. Re-approval triggers tied to tool definition changes are the specific control that stops rug pulls before they do damage, and the stakes here are concrete: The State of MCP Security in 2026 found that 20% of skills in OpenClaw's marketplace were malicious.
Supply chain controls for external MCP servers should mirror what software supply chain security already does elsewhere: version pinning, signed tool definitions, dependency audits, and ongoing monitoring for any change in a server's behavior or ownership. Auto-approval of tool invocations should be disabled across every production deployment, with OAuth 2.1 authentication, least-privilege scoping, and structured audit logging enforced on every external MCP server connection without exception.
Tool poisoning and supply chain attacks call for runtime detection built specifically for MCP, tuned to watch not just what an agent does but what's hidden inside the tool descriptions it reads.
Data residency controls need to account for how MCP actually routes traffic. If an agent's tool discovery runs through third-party cloud infrastructure, data can leave the network boundary on every single interaction, not just the obvious ones. Each external agent's reach should get classified against the specific regulatory obligations that apply, whether that's HIPAA, GDPR, or financial services data residency rules, before that agent goes anywhere near production.
Sources
- MCP Security Risks in 2026 and Registry Controls
- Securing AI agents: When AI tools move from reading to acting | Microsoft Security Blog
- The State of MCP Security in 2026
- Enterprise-Grade MCP Specification Introduces Critical Security Challenges
- The AI Agent Governance Gap: What CISOs Need Now – Lab Space
- Model Context Protocol (MCP): Security Design ...
- IAM for AI agents: A Practical Enterprise Framework


