What happened
Microsoft describes Agent Controls as a managed policy service built on the open-source Agent Control Specification (ACS) and Agent Hooks. It is meant to govern actions as well as generated text. Policies can cover tool execution, business transactions, access to sensitive information, and agent responses. The service evaluates proposed content or an action, then returns a decision such as allow, deny, or transform. The agent runtime or application, rather than Agent Controls itself, must enforce that decision.
Agent Hooks defines standardized intervention points in an agent lifecycle. Microsoft lists incoming input, model interactions before and after a request, tool execution before and after a call, final output, and session startup and shutdown. ACS supplies a policy model and evaluation runtime intended to let developers express a rule independently of a specific agent implementation. Microsoft says a policy can combine deterministic business rules, content-safety classifiers, and supported LLM-based evaluations. Its documented annotators are Azure AI Content Safety classifiers and LLM judges whose criteria are written in the policy.
The managed flow starts with a policy owner authoring and publishing an ACS policy. An agent host intercepts an event, sends the proposed action and runtime context to Agent Controls, and receives a verdict with decision details. The host then allows, blocks, or applies a permitted transformation. Microsoft illustrates the flow with a refund policy: a refund up to $100 can be allowed, a $150 refund can be denied, and a $75 refund can proceed. A policy can also return a deny result accompanied by an approval request for the host's review workflow.
The enforcement distinction is explicit. Microsoft says the host must report the actual action and use evaluated values. Evaluating one set of tool arguments and dispatching another bypasses the policy. Agent Controls does not execute the agent's tools, sandbox its process, or govern a route that bypasses the host's interception code. It also does not turn a model-generated identity claim into trustworthy authorization. Authorization and authoritative business data remain the responsibility of trusted application systems.
Microsoft exposes an Azure Resource Manager (ARM) control plane for publishing, updating, and managing ACS policy resources and reusable Rego modules. Its Unified Moderate data-plane API evaluates actions and content against centrally managed policies; the page identifies 2026-09-01-preview as the API version. A standalone request selects a published policy using policyId; a separate resource-binding route uses targetResourceId, and Microsoft says callers should not send both. During public preview, billing covers classifier and LLM usage triggered by policy evaluation. Content Safety classifiers follow their own pricing, while an LLM judge also incurs associated model-usage charges.
What the archive adds
New Runtime covered Microsoft's Copilot harness in Foundry Agent Service on 2026-11-03, describing a managed agent loop and sandbox. Agent Controls is a new fact on the broader Foundry story: it adds a centrally managed policy-evaluation layer, while the agent host remains responsible for execution and enforcement.
Trend signal
This supports agent security moves to runtime boundaries: the documented control point is a runtime interception boundary, not a prompt alone. The distinction is consequential. Microsoft says the host must provide trustworthy context and enforce a verdict, while Agent Controls cannot govern execution paths that bypass interception.
Why now
Microsoft frames the need around agents moving beyond conversation into tool use, transactions, and enterprise-system access. A prompt can describe a refund limit, but cannot independently stop a prohibited tool call once a host elects to execute it. The service is in public preview, and Microsoft last updated the page on 2026-11-19.
Connections to other events
An earlier New Runtime note on 2026-11-03 described Microsoft opening its Copilot harness in Foundry Agent Service as a public preview, with a managed agent loop, sandbox, skills, connected tools, and code execution. Agent Controls addresses a different layer: it evaluates whether an action at a lifecycle boundary should proceed, but does not operate the agent or its sandbox.
Why it matters
For a team operating many agents, centrally managed policies can reduce repeated implementation of common limits. A refund threshold, destination restriction, or sensitive-data rule does not have to live separately in every system prompt and tool wrapper. ACS is also designed for a heterogeneous environment, so an organization can retain a common policy model across agents built in different frameworks or hosted in different places.
That benefit comes with an architectural obligation. The host is part of the security boundary: it has to stop at the relevant intervention point, construct accurate context, apply the returned decision, and ensure the dispatched operation is the evaluated operation. Teams should treat Agent Controls as a governance layer around agent execution, not as a replacement for application authorization, trusted business records, process isolation, or carefully scoped tool permissions.
Limits and uncertainty
The service is in public preview. Microsoft does not establish production reliability, end-to-end latency, or the operational cost of policy evaluation at scale. Its page describes classifiers and LLM judges but gives no comparative accuracy, false-positive, or false-negative measurements for those evaluations. It also does not remove implementation risk from the host: an incomplete interception integration, inaccurate runtime context, or a path that executes outside the checked flow can evade the intended policy. Teams will need to test policies, enforcement behavior, approval routing, and cost under their own tool schemas and workloads.
Skill to build now
Choose one consequential tool call this week, such as issuing a refund, changing an account setting, or sending data outside the organization. Define the allowed arguments as a deterministic rule, intercept the call before dispatch, and test that the host blocks an over-threshold request using the same arguments it will execute. Keep authorization separate from the policy check: Agent Controls can evaluate a proposed action, but the application still has to establish who is allowed to request it.
Reader takeaway
Agent Controls makes policy evaluation centrally manageable across agent applications, but it is not a remote kill switch. The durable control remains in the host: intercept the real action, evaluate the real context, and enforce the verdict before any tool call or release proceeds.