Why platform-native controls are not the full governance answer
Platform engineering teams building agents on Microsoft Foundry often assume that the platform's built-in identity and orchestration features are sufficient for enterprise security requirements. That assumption breaks down once agents move from static workflows to autonomous, tool-calling behavior. Native identity and permission systems on most agent platforms are designed to answer a narrower question: can this deployed application authenticate to this resource. They are not always designed to answer a harder question: should this specific agent, in this specific context, be allowed to invoke this specific tool with these specific arguments, right now.
The first question is typically resolved at deployment time. The second question can only be resolved at runtime, and it requires a different kind of control entirely. This distinction matters because agents built on Foundry frequently gain access to internal APIs, databases, and third-party tools that were never designed with autonomous, non-human callers in mind. Treating deployment-time permission grants as equivalent to runtime enforcement creates a governance gap that widens as agents are given more autonomy and more tool access.
What identity and permissions typically cover, and where they stop
Identity mechanisms on agent orchestration platforms generally bind to the deploying application or service rather than to the individual agent or agent session. This is a meaningful architectural detail: if permissions are scoped to the application rather than the agent, then every agent instance running under that application inherits the same access, regardless of what that particular agent actually needs to do. Least-privilege access requires permission grants that map to agent function, not to the broader service identity.
Equally important is where enforcement actually happens. Many platforms enforce permissions at the point of resource provisioning, meaning access is granted or denied when a connection is configured, not when an individual tool-call is made. This model does not prevent an agent from using a legitimately provisioned connection in an unintended or over-broad way during execution. Enterprises should treat static, deployment-time permission configuration as a starting point, not as evidence that runtime access is properly constrained.
Tool-call governance and the MCP trust boundary
As agents connect to external tools and data sources, including integrations built on Model Context Protocol or similar standards, a new trust boundary is introduced between the agent and the systems it can act on. This boundary is distinct from traditional network or application trust boundaries because the caller is an autonomous process making its own decisions about which tool to invoke and with what arguments. Identity models built for human users or fixed service accounts do not automatically extend to this kind of dynamic, per-call decision-making.
Without a policy enforcement point positioned between the agent and its tool connections, there is no reliable way to inspect, approve, or deny a specific tool invocation before it executes. This is the core of tool-call governance: it is not about whether a connection exists, but about whether each use of that connection is appropriate given the current context, and whether that decision can be enforced consistently across every agent using the same integration.
Treating least privilege as a continuous control
Least-privilege enforcement is often described as a one-time configuration step: define a role, attach a policy, deploy. For autonomous agents, this framing understates the problem. An agent's behavior can vary across sessions based on inputs, context, and the tools it chooses to invoke, which means permission boundaries need to be evaluated continuously rather than verified once at setup.
This is why runtime policy enforcement, agent identity management, and tool approval workflows function as a connected set of controls rather than independent features. Audit logging closes the loop by giving security and compliance teams a record that reflects actual agent decisions, not just system-level requests, which matters for both internal risk review and external audit requirements. Enterprises should document explicitly where platform-native controls end and where additional runtime governance begins, so that gap is understood by security, compliance, and engineering stakeholders alike rather than discovered during an incident.