Implementation Guide

Governing AI Agents in Microsoft Foundry

Microsoft Foundry provides deployment-time identity and permission scaffolding for AI agents, but enforcing least-privilege access, controlling individual tool-calls, and producing audit-grade logs at runtime typically requires an additional governance layer sitting between the agent orchestration engine and the tools or data it calls.

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.

Four governance gaps to close before production

Native Foundry controls establish a useful baseline. The following gaps are where most agent deployments need an additional runtime layer.

Agent Identity

Scoping identity to individual agents, not shared service accounts.

Least Privilege

Enforcing permissions at the tool-call level, not just deployment time.

Tool-Call Oversight

Inspecting and approving actions in real time, before execution.

Audit Logging

Capturing decision context, not just request and response events.

Evaluation questions before production deployment

Use these questions to assess whether an agent platform's native controls are sufficient, or whether a runtime governance layer is needed.

  • Does the platform enforce tool-call permissions at runtime, or only at deployment configuration?
  • Can agent identities be scoped to individual tools and data sources rather than broad service accounts?
  • Do audit logs capture tool-call arguments and outputs, or only high-level invocation events?
  • How are MCP-based or external tool connections authenticated, and are credentials shared or per-agent?
  • Who owns policy definition, exception approval, and incident response for agent actions?

Close the gap between deployment-time controls and runtime enforcement

Trussed AI provides runtime governance for AI agents, including agent identity, least-privilege permissions, tool approval workflows, and audit logging that operate alongside your existing platform deployment.

Request a Demo