Implementation Guide

Governing AI Agents in Microsoft Foundry Agent Service

Governing agents on Foundry Agent Service requires two distinct layers: platform-level identity and access controls that govern who can create, deploy, and invoke an agent, and a runtime governance layer that controls what an agent does once it is running, including which tools it can call, with what parameters, and under what audit trail. Platform engineering teams should verify current identity and access mechanisms directly against Microsoft's published documentation, then build or adopt a runtime policy and tool-call governance layer to close the gap between deployment-time access and execution-time behavior.

Questions to Answer Before Scaling Agent Deployments

Use this checklist to assess whether your current platform controls and internal processes are sufficient before expanding agent deployments beyond initial pilots.

  • What identity model does the platform assign to a deployed agent, and is that identity distinct from the identity of the developer who deployed it?
  • Can tool calls be constrained or require approval before execution, or does the platform only control which tools are registered to an agent?
  • What audit log format, retention period, and export mechanism are documented for agent actions, and does that log capture tool call arguments as well as outcomes?
  • Which governance responsibilities does the platform vendor explicitly assign to the customer versus retain itself?
  • How frequently do platform release notes change identity, permission, or logging behavior, and who on the team is responsible for tracking those changes?
  • If an agent takes an unexpected action in production, what evidence exists to reconstruct the decision path after the fact?

Why Runtime Governance Becomes a Platform Engineering Problem

Deploying an agent on a managed service handles a specific set of concerns: provisioning, deployment, and integration with the underlying model and tool ecosystem. It does not automatically answer the questions enterprise security and platform teams are accountable for once agents are live: which identity is the agent operating under, which tools and data sources can it reach, and what happens when it takes an action outside expected bounds. As agent usage scales past a handful of pilot deployments, these questions move from theoretical to operational. Platform engineering teams end up owning governance by default, whether or not the underlying platform was designed with that responsibility in mind.

The Governance Boundary Every Agent Platform Draws

Cloud-hosted agent services generally separate two concerns. The first is access management: who can create an agent, deploy it, assign it credentials, and invoke it. This is typically handled through the cloud provider's existing identity and access management system, extended to cover agent resources. The second is behavioral governance: once an agent is running, what determines which tools it selects, what parameters it passes, and what data it touches. These are architecturally distinct problems. Access management answers who is allowed to operate the agent. Behavioral governance answers what the agent is allowed to do while it operates. A platform can provide strong controls for the first without providing equivalent controls for the second, and the two should not be assumed to overlap without direct verification against current platform documentation.

Where Native Platform Controls Typically Stop

Across managed agent platforms generally, native identity and access controls tend to be strongest at the deployment boundary and weaker at the execution boundary. Deployment-time controls answer questions cloud IAM systems are built to answer well: authentication, role assignment, resource-level permissions. Execution-time questions, such as whether a specific tool call should be permitted given the agent's current context, whether a parameter value falls within an approved range, or whether a sequence of actions represents a pattern requiring human review, are a different category of control. These require policy logic that evaluates each tool call against defined rules at the moment of execution, not just at deployment. Whether and how Foundry Agent Service currently implements this category of control should be confirmed against Microsoft's current documentation before any enterprise architecture decision is finalized, since platform capabilities in this space are actively evolving and specifics can change between releases.

Implementing a Runtime Governance Layer

  • Define agent identity separately from developer or service account identity, so agent actions are attributable to the agent itself in audit records.
  • Establish least-privilege tool access per agent role, rather than granting broad tool access at deployment and relying on the model to self-restrict.
  • Introduce approval workflows for tool calls that touch sensitive systems or irreversible actions, independent of whether the platform provides this natively.
  • Log every tool call with its parameters, not just its outcome, so audit records support root-cause analysis rather than only confirming that an action occurred.
  • Review platform release notes and documentation on a fixed schedule, since identity and permission mechanisms in managed agent services change over time.
  • Treat platform-native access controls and runtime tool-call policy as two separate control surfaces requiring separate verification and separate ownership.

Where a Runtime Governance Layer Fits

Trussed AI provides a runtime governance and security layer for enterprise AI agents, covering agent identity, least-privilege permissions, tool approval workflows, runtime policy enforcement, and audit logging. This layer operates as a complement to whatever identity and access controls the underlying platform provides, rather than a replacement for them. For teams running agents on Foundry Agent Service, the relevant question is not whether the platform is secure in general, but whether tool-call decisions during execution are governed by explicit, auditable policy, and whether that governance layer exists independently of individual agent configuration. Where native platform documentation confirms this capability, it should be used directly. Where it does not, a dedicated runtime governance layer closes that gap.

Governance Domains for Deployed Agents

Four distinct domains together define whether an agent deployment is governed end to end, from who can invoke it to what it does while running.

Agent Identity & Access

Who can create, deploy, and invoke an agent, and under what credentials.

Tool-Call Governance

Which tools an agent may invoke, with what parameters, and under what conditions.

Runtime Policy Enforcement

Rules applied to agent behavior during execution, not just at deployment time.

Audit & Traceability

Recording agent actions and tool calls in a form suitable for review and incident response.

Frequently Asked Questions

Does this guide confirm specific Foundry Agent Service governance features?

No. This guide provides a framework for evaluating governance requirements and identifies the general architectural distinction between deployment-time access control and runtime tool-call governance. Specific current capabilities of Foundry Agent Service should be verified directly against Microsoft's published documentation, since platform features change between releases.

What is the difference between platform IAM and runtime governance?

Platform IAM governs who can create, deploy, and invoke an agent. Runtime governance governs what the agent is permitted to do once it is executing, including which tools it calls, with what parameters, and under what audit trail. Strong IAM does not imply strong runtime governance.

Where should a platform engineering team start?

Start by confirming current identity, permission, and logging mechanisms against official documentation, then map every tool an agent can access against a least-privilege policy. Identify any tool calls that should require approval before execution, and ensure audit logs capture parameters, not just outcomes.

Close the Gap Between Deployment and Runtime Governance

Deployment access controls answer who can run an agent. Runtime governance answers what the agent is allowed to do while it runs. Trussed AI provides the runtime governance layer, including identity, least-privilege permissions, tool approval workflows, policy enforcement, and audit logging, for agents deployed on managed platforms.

Explore Runtime Governance