What Makes This Different From Traditional Application Security
In conventional application security, a trust boundary is drawn at design time. A web application has a known set of code paths: a request enters through an API gateway, passes through authentication, and reaches a database with a fixed set of permitted queries. The boundary between untrusted input and trusted execution is static and can be reviewed once during architecture design.
Agentic AI systems do not work this way. An agent decides, at runtime, which tool to call, what parameters to pass, and in some architectures, which other agent to delegate a subtask to. The sequence of actions is composed dynamically based on model output, not fixed in advance. This means the trust boundary is not a single line in the architecture diagram but a condition that must be evaluated at every point where control, data, or authority passes between components with different privilege levels. NIST's AI Risk Management Framework reflects this distinction directly, noting that systems with greater autonomy require enhanced monitoring because their actions cannot be fully predicted through static code analysis.
How Violations Occur in Practice
Most trust boundary violations trace back to one of a small number of mechanisms rather than a single root cause.
Delegated tool calls are the most common vector. When an agent invokes a tool on behalf of a user, it can inherit or exceed that user's actual permissions if the invocation is not scoped and checked independently at call time. A session-level permission grant is not sufficient if individual tool calls within that session are never re-evaluated.
Shared context and memory create a second vector. If memory or conversation state persists across sessions, users, or tenants without partitioning, an agent can surface data or instructions from one trust level into a context where they should not be visible.
Inter-agent communication is a third vector, and one that OWASP's agentic AI guidance treats as introducing trust boundary considerations that do not map to conventional client-server models. When one agent delegates work to another, that handoff crosses a boundary. If it is implicitly trusted rather than authenticated and policy-checked, privilege can propagate further than intended.
OWASP's LLM Top 10 names the resulting condition directly as Excessive Agency: granting an agent more functionality, permission, or autonomy than its task requires.
MCP and the Protocol-Level Attack Surface
The Model Context Protocol, published by Anthropic, defines a standardized client-server architecture for connecting AI models to external tools and data sources. Standardizing this interface reduces integration friction, but it also concentrates risk at the protocol layer. If authorization is not enforced consistently at that layer, every tool connected through it inherits the same exposure.
The MCP specification addresses this by recommending OAuth 2.1-based flows for securing communication between clients and servers, rather than static API keys. Independent security research has documented practical risks in current MCP deployments, including tool poisoning and unauthorized data exposure resulting from overly permissive tool access, along with a lack of standardized identity verification between agents and MCP servers. These findings come primarily from practitioner and vendor research rather than formal incident data, but they point to a consistent pattern: protocol-level interoperability increases the blast radius of a single authorization gap.
Implementation Considerations for Security Teams
Before deploying agents to production, map every tool-call and inter-agent communication path to identify where privilege or data actually crosses a boundary. This mapping should be treated as a prerequisite to deployment, not a retrospective audit step.
- For protocol-based tool connections, including MCP, use token-scoped authorization such as OAuth flows rather than static API keys, and verify that the token scope matches the specific action rather than granting broad access to an entire tool server.
- High-impact or irreversible actions identified during design, such as financial transactions, data deletion, or external communications, should require human-in-the-loop approval rather than autonomous execution.
- Log tool invocations and inter-agent messages with enough granularity to reconstruct the chain of delegated authority after an incident. Without this, determining which agent or delegation step caused an unauthorized action becomes difficult after the fact.
- Test agent behavior against adversarial or unexpected inputs, including prompt injection and tool-poisoning attempts, to confirm that permission boundaries hold under conditions the agent was not explicitly designed to handle.
Why mapping comes first
Without an explicit map of tool-call and delegation paths, it is not possible to know where scoped authorization actually needs to be enforced, which makes later audits far more difficult to reconstruct.
Governance Context and Current Limitations
No regulatory framework currently mandates trust boundary controls specific to AI agents. Existing guidance is drawn from adjacent frameworks: NIST's AI Risk Management Framework for general AI risk, OWASP's LLM Top 10 for application-level risk categories like Excessive Agency, and NIST SP 800-207 Zero Trust Architecture for the underlying principle that trust should be evaluated per-request based on identity and context rather than network location or a one-time grant.
Organizations should document agent permission scopes and delegation chains as part of their AI governance records to support later audits, and should treat current vendor and standards-body recommendations, including the MCP authorization specification, as evolving best practice rather than settled standard. The maturity of runtime policy enforcement tools also varies significantly across vendors, and no independent benchmark data currently exists comparing their effectiveness.