Microsoft published a public preview of agent controls on 18 November 2026, a managed Azure service that stores agent policies centrally and evaluates them at runtime. Policies use the open Agent Control Specification (ACS), and agents reach the service through Agent Hooks interception points. Our October post compared the ACS projects and the Agent Hooks contract; this one covers the hosted service.
The announcement calls the preview an enterprise control plane for agent behaviour. The documentation describes a hosted decision API: each call returns a policy verdict for one event. Enforcement, outage handling, the human approval workflow, running totals for aggregate limits, account authorisation inside each tool and the record of what actually ran all sit in the host application. We read the announcement and the Microsoft Learn documentation, checked the linked material on 20 November, and wrote a test plan for the host side. This post belongs to our research notes on agent execution: each one reads a recent source closely, reports what we checked ourselves, and ends with a resource you can use on your own system.
What Microsoft announced
The announcement, Introducing agent controls: An enterprise control plane for agent behavior, is by Mehrnoosh Sameki, Mohamed Elmergawi, Mike Shi, Liam Crumm and Microsoft’s Responsible AI team. Read the announcement.
Policies live on an Azure AI Content Safety account: Rego modules are uploaded as raiRegos resources, the ACS manifest is published as a raiPolicies resource, and an optional raiBindings resource ties a policy to an agent resource. At each configured intervention point, the host sends the event to the Unified Moderate endpoint and receives a verdict. A policy can combine Content Safety classifiers, LLM judges written by the customer, and Rego rules that combine their results with the request context. Microsoft Learn says preview customers pay only for the classifier and model usage their evaluations trigger, and the service needs an account enabled for the preview in a supported region.
Agent Hooks defines eight interception points. The current Unified Moderate version, 2026-09-01-preview, accepts four event sources: input, output, pre_tool_call and post_tool_call.
The decision contract
The service returns allow, deny or transform. Warnings travel as metadata on a verdict. A human review is expressed as a deny that carries an approval object, and Microsoft Learn is direct about what that means: “A review decision is a deny until your host resolves it.” and “The approval field does not open a review queue or grant permission.” The same page tells hosts to “Bind any approval to the exact action and evaluated values.” API and operations.
Failure handling and response parsing are also the host’s. HTTP 200 means only that the evaluation completed; the response carries a verdict of allowed or blocked beside acsVerdict.decision. Learn tells hosts to keep the action blocked on HTTP 429, 500 and 503, on transport errors and timeouts, and on malformed or inconsistent verdicts, retrying within a bounded deadline. The overview adds that the host must dispatch the values it had evaluated: “Evaluating one set of tool arguments and dispatching another bypasses the policy.” The approval lifecycle post shows what goes wrong in the host between a decision and its effect.
Reading the Caldova example
The announcement’s example bank, Caldova, has three rules: transfers over $10,000 go to human review, a customer in financial hardship is handed to a specialist, and no customer PII leaves in a response. The policy binds a hardship judge to input, a transfer rule to pre_tool_call and a PII classifier to output.
- The printed transfer rule denies the transfer outright. The Rego module defaults to deny with reason
tool_call_not_permittedand allowstransfer_fundsonly for USD amounts above 0 and up to 10,000. A $25,000 request falls to the default deny. Sending it to review needs an approval-bearing deny and a review workflow in the host, neither of which the example provides. - The tool still checks the account. After the lookup rule, the article states: “The tool implementation still checks the caller’s access to that account.” Policy screens the call; the tool enforces the entitlement.
- A per-call limit sees one call. The rule checks each transfer on its own. A daily or per-customer limit needs authoritative running totals supplied in the request context.
- The judge returns rubric scores. The hardship judge labels a message
hardship,no_hardshiporuncertainwith scores 10, 0 and 5, which the rubric itself says are not probabilities. The stop on credit offers and the handover are host behaviour.
What a receipt records
The announcement says: “Each evaluation also returns a receipt that identifies the policies and versions applied. Applications record these receipts alongside execution outcomes, so teams can trace each action back to the policy decision.” The response fields documented on Learn are a verdict, the original or transformed content, and an acsVerdict with the decision, reason, message, warnings, approval, transform, evidence and classifier results. Neither source shows a field named receipt, a signature or a verification procedure.
So the receipt, as published, identifies the policy, and the response schema shows no signature. The link to the action rests on the host: what it recorded about the event it sent, the arguments it dispatched and the outcome it observed. If you need to show an auditor later that a specific action ran under a specific policy version, write that correlation yourself and protect it as evidence.
What we checked on 20 November
Each check is listed with its result in an appendix to the host test plan.
- Samples. The article links samples under
microsoft-foundry/foundry-samples. The tree returned HTTP 404, and the GitHub API returned 404 for the repository itself. The announcement, the Learn pages and the open ACS and Agent Hooks repositories all returned 200. - Policy selector. The article passes the policy’s full ARM resource ID as a URL-encoded
policyIdquery parameter. The Learn API guide puts the published policy’s name in the JSON body aspolicyIdand tells callers to keep it out of the query string. All pages agree on API version2026-09-01-preview; follow Learn when the two differ. - Framework support. Microsoft Agent Framework documents Agent Hooks as experimental in Python and not yet implemented in .NET or Go. Tools executed by the model provider pass
post_model_callonly, sopre_tool_callcannot block their server-side execution. - Enforcement limits in the documentation. The Learn overview states that agent controls “doesn’t run your agent, execute its tools, sandbox its process, or control a path that bypasses your interception code.” A
post_tool_calldeny stops the agent using a result; the tool’s side effects have already happened. Agent Framework buffers output until the output check passes; a host that streams tokens before that check cannot take them back.
A test plan for the host
None of this is unusual for a decision service, and the same tests apply to any hosted policy engine, KLA’s included. A preview with no published latency, bypass or outcome measurements makes them worth running before production. The host test plan lists fourteen cases; here are seven.
| Case | What to do | Pass when |
|---|---|---|
| Dispatch matches evaluation | Change an argument after the verdict | The changed call is re-evaluated or refused |
| Review requested | Return a deny carrying approval | Action stays blocked until your workflow records a decision bound to the evaluated values |
| Service unavailable | Force 503 and a timeout | Action stays blocked; retry ends at a deadline; event recorded |
| Uncovered path | Run a tool the model provider executes server-side, or a path without the hook | Listed as uncovered in your control inventory, with its own control |
| Transform | Return a transformed tool argument | Replacement validated against your schema before dispatch, applied once |
| Aggregate limit | Send two transfers under the per-call limit that exceed the daily limit | Second is denied because the context carried the running total |
| Correlation | Pick one dispatched action from last week | You can name the policy version, the event sent, the arguments dispatched and the observed outcome |
How KLA differs in design
KLA places the approval workflow and the evidence inside the control plane. The KLA Policy Engine returns one of four outcomes: allow, warn, require_approval or block. A require_approval outcome opens a Decision Request in KLA, and for actions through KLA agent action ingress the approval is bound to the proposal’s fixed arguments and argument hash. When evaluation fails, the engine returns its fail-closed decision, require_approval by default. Outcomes are written as signed governance receipts to a per-tenant append-only ledger, and Sealed Evidence Bundles carry the public keys an offline verifier needs. As with any decision service, an agent that never calls KLA is not governed by it.
Frequently Asked Questions
What is Microsoft agent controls?
A managed Azure service, in public preview since 18 November 2026, that stores Agent Control Specification policies as Azure resources and evaluates agent events through a hosted API called Unified Moderate. Policies can combine Content Safety classifiers, LLM judges and Rego rules. The calling host enforces the result.
Does Microsoft agent controls support human approval?
A policy can return a deny that carries an approval object. Microsoft Learn states that the approval field does not open a review queue or grant permission: the host must run the review workflow and bind any approval to the exact action and evaluated values.
What happens if the agent controls service is unavailable?
Microsoft Learn tells hosts to keep the action blocked on 429, 500 and 503 responses, transport errors and timeouts, and to retry only within a bounded deadline. That behaviour depends on the host implementing it.
Are agent controls receipts tamper-evident?
The announcement says each evaluation returns a receipt identifying the policies and versions applied. As of 20 November 2026, neither the announcement nor the Learn API reference shows a receipt schema, a signature or a verification procedure, so tamper evidence is not established by the published material.
Key Takeaways
Agent controls gives teams a central place to write and evaluate agent policy across frameworks. The decision is one step; the host still dispatches the evaluated values, runs the review, keeps actions blocked when the service fails and records what actually happened. Test those host paths before production with the host test plan.
Sources were checked on 20 November 2026. We had no preview account and ran no evaluation against the service. Microsoft published no latency, bypass or outcome measurements for it. This post contains no KLA production result.
