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.