One case. One limit.
Apply the total to the business case, not separately to each call. New sessions, retries and other authorized agents must respect what is already committed.
Use cases / Azure
Build on Azure. Govern the whole workflow.
Govern the business case—not just the current call. Keep shared limits, owner approvals and decision evidence connected, even when the entire workflow stays in Azure.
One Azure tenant. One business case. Rules that hold across sessions.
Sample data
Ⅱ HOLD
Above $500. Finance owns approval.
$900 is above the $500 automatic threshold, so it is held for Finance before the refund API is called. A request nobody decides expires after 15 minutes.
Amount: $900To: original payment methodAutomatic up to $500
requestrefund.create 900 → original payment method
policyfinance.refunds r15 · Finance above $500 · original payment method only
verdictHOLD · Finance lead · before dispatch
allowed is not executed · browser exampleInspect this decision
A held request is not sent until Finance decides. Who approved, and when, is recorded with the decision.
Open the full Azure example ↓Built around your stackMicrosoft FoundryAzure OpenAIMicrosoft EntraAPI ManagementMCP + enterprise tools
Why GovernorAI—even on Azure alone
New session.
Same business limit.
A customer case does not start over when an agent opens a new session. GovernorAI keeps the shared limit, accountable owner and decision history connected—even with one agent, one Azure tenant and no second platform.
Finance owns the exception.
Route the request to its owner and record the decision. An approval does not release the call, a new amount is a new request, and an approval never overrides the hard case limit.
Keep the whole decision.
Connect the policy, shared exposure, approval and observed result. Keep evidence useful when agents, tools or platform versions change.
Keep your Microsoft controls.Connect business limits, approvals and evidence around the native controls you already trust.Try a refund decision ↓
In the product
See one policy previewed for Azure OpenAI, in the console.
Recorded on a demo tenant: one governance policy previewed as a cloud guardrail, the same policy and the same hash previewed for Azure OpenAI, every agent on one map, and decisions from every platform in one log.
One policy, step by step
Real product screens from a demo tenant with seeded activity. The provider outputs are previews of what the policy becomes for each target; nothing was applied.
Recorded against a demo tenant with seeded activity. Real product screens, not a mock-up.
Execution control / one Azure tenantAZURE-ONLY WORKFLOW · SYNTHETIC DATA
A governed action boundaryrun-azure-0182
Microsoft Foundryrefund-assistant
GovernorAIAPIM + tool broker
Refund instructions APINot dispatched
- Requested action
- refund_instruction.create · $900
- Authority
- Entra agent + customer scope
- Business policy
- finance.refunds
- Required reviewer
- Finance lead · requests expire after 15 minutes
GovernorAI decision
Ⅱ HOLD FOR APPROVAL
Above $500. Finance owns approval.
This $900 refund instruction is above the $500 automatic threshold. It is held for Finance before the refund instructions API is called.
No approval, no refund-instruction dispatch.
This sample action0 dispatched1 awaiting approval
Browser-only sample · unsigned · illustrative fields, not an Azure API contract.
Azure-only examples. Foundry → governed action adapter → customer API on App Service → Azure SQL. The refund example authorizes but never dispatches, and settles no payment.
Keep useful work moving.
Let routine, authorized actions proceed without putting a human in every loop.
Make exceptions deliberate.
Give consequential actions a named approver and a recorded decision.
Show why it happened.
Connect the policy, decision, approval, and execution outcome in one record.
Native controls + a connected operating workflow
Keep your Microsoft stack.
Govern the whole workflow.
Keep the Microsoft identity, policy, security and gateway controls you already use. GovernorAI connects them to the whole business decision: prior commitments, current approval, the action being taken and its accountable outcome.
Microsoft Entra
The identity and access foundation for agents and the people they act for.
Foundry + Azure OpenAI
The agents and models your teams use to build and run AI-powered work.
API Management
The gateway for model, API, and MCP traffic, with your native policies intact.
Purview + Defender
Data protection and threat signals, with Sentinel supporting security operations.
GovernorAI / Independent execution governance
Business policy → Human authority → Controlled action → Evidence
Agent teams build. Business owners authorize. Reviewers verify. Separate policy ownership from agent authorship, while retaining your native controls.
Even on one platform
Even if everything you run is on Microsoft.
"Single cloud" describes where your agents run. Governance is about what they do, who answers for it, and what you can prove. Microsoft’s stack answers who the agent is and what it may touch. The business decision sits above it.
Microsoft governs the agent. You still own the decision.
Entra Agent ID and Agent 365, both generally available since May 2026, together with Foundry Control Plane, Purview and Defender, establish who the agent is, what data it may touch and whether it is under attack. GovernorAI consumes all three as inputs and decides the business action above them: may this refund be issued under this case’s limit, and who in Finance said yes.
Registered is not the same as governed.
Agent 365 governs the agents in Microsoft’s registry, and third-party and non-Microsoft agents once they are registered there. Discovery that is independent of the tenant counts the agent nobody registered, and refuses to call an uninstrumented path governed.
The record should outlive the console that wrote it.
When the policy editor, the enforcer and the audit log all sit in the tenant your builders administer, risk and audit have no independent line. SOC 2, ISO/IEC 42001 and the NIST AI RMF expect that separation, and an auditor wants the chain from authority to outcome long after agents, tools and tenants change.
One refund request, end to end.
In this example, Microsoft's stack establishes who the agent is, what data it may reach and whether the tenant is under attack, and the refund rule is managed in GovernorAI.
- Microsoft In this example, the configured Entra Agent ID and Conditional Access policies let the agent reach the refund API, and Purview and Defender protect the data and the tenant.
- GovernorAI The refund policy managed in GovernorAI requires refunds to return to the original payment method. This one names a different card, so it is denied before the request reaches the API.
- Agent The agent receives the rule and the reason, not a bare error, and can retry correctly.
- Record The decision record names the agent, the rule that decided and the outcome, kept outside the tenant's own console.
And when you are not single-cloud: one policy, one ledger, one evidence chain across Azure, AWS, Google Cloud, Databricks, Kubernetes, MCP, Salesforce and ServiceNow. See how one policy governs everywhere
One source policy. Clear enforcement responsibility.
Your rules. Azure’s controls.
Nothing silently lost.
Compile native controls where they fit. Keep action-level authority in GovernorAI. See how every rule is represented—and where it is enforced.
Deep Azure integration
Keep your architecture.
Add shared authority.
From Foundry and Copilot Studio to your gateways, custom runtimes, and enterprise tools. Connect the estate to one policy and evidence lifecycle.
Foundry + Copilot Studio
See the agent estate.
Bring agents, deployments, owners, and reachable tools into view. Name permission gaps instead of mistaking an incomplete inventory for an empty estate.
Discovery · Ownership · Policy scope
Azure OpenAI + Foundry
Govern the model request.
Apply approved deployments and request constraints. Verify policy-required changes before the outgoing call proceeds.
Model controls · Verified request shaping
API Management + MCP + A2A
Decide before tools act.
Check the operation, arguments, and caller at the action boundary. Keep gateway routing and existing security policies in place.
Tool calls · Agent handoffs · Business context
Microsoft Entra
Carry identity into authority.
Connect agent identity, human ownership, delegation, and reviewer roles to the exact action being requested.
Agent ID · Delegated user · Authorized reviewer
AKS + Container Apps + App Service
Keep decisions close to work.
Apply policy in your runtime and tool adapters. Local evaluation and run-level limits keep routine decisions beside the agent.
Local policy · Step limits · Spend controls
Microsoft security + Azure applications
Connect security and evidence.
Bring governed application actions and decision evidence into your Azure security and operations workflow. Keep the business rule connected to the observed result.
Azure applications · Microsoft Sentinel · Evidence
See where control is activeKnow which actions
Know which actions
are actually governed.
See each action path, its policy attachment and what still needs attention. Start from a defined workflow scope—not a reassuring inventory count.
Illustrative coverage view · 4 selected action paths3 enforced / 4 scoped1 needs attachment
Refund instructions APIApp Service · policy r15 · before dispatchEnforced
Order lookup toolApp Service · policy r8 · before dispatchEnforced
Production archive toolRuntime adapter · policy r6 · before dispatchEnforced
New reporting toolDiscovered · no verified action attachmentNeeds attachment
Evidence that follows the action
Don't just log the call.
Show the authority
behind it.
Connect the agent, policy, human authority, and action outcome. Give security, platform, and GRC teams the same decision trail.
Keep policy, approval and outcome evidence under your retention rules—not tied to an agent’s lifetime. A hash-chained control-plane audit log, and signed exports where a deployment enables signing, support the review.
Explore evidence + complianceSentinelLog AnalyticsEvent HubsControl evidence export
Decision trail / AzureLINKED TO THE EXAMPLE ABOVE
Sample run
Agent
Request
Policy
Decision
Authority / checks
Dispatch
Business outcome
Illustrative, unsigned sample · Authorization and execution are separate events.
Start with one consequential workflow
Move forward.
Without a big-bang rollout.
Connect through Azure-native identity. Start with read-only discovery, test a fixed agent snapshot, then activate the governed workflow with your team in control.
01
Discover
Map agents, owners, deployments, and tools. Surface any missing discovery permissions.
02
Assure
Gate release against agreed tests. An unassessed requirement never becomes a pass.
03
Govern
Review the source policy, native translation, and shadow decisions together.
04
Enforce
Activate the chosen action boundary, approval path, and run limits.
05
Prove
Review the decision trail and execution evidence before widening the scope.
One Azure workflow. A native-controls baseline. Agreed success criteria for control and operating effort.
Discuss your Azure workflowValue now. Consistency as you grow.
Stay on Azure.
Take your rules further when you’re ready.
Start with the platform you already use. Extend the same policy intent and evidence lifecycle across supported clouds, SaaS and private runtimes when the business needs it—not to justify the first workflow.
Same business rule. Explicit native mappings. A connected governance process.
The questions worth asking
Built to fit.
Built to make
a difference.
We only use Azure. Is GovernorAI still relevant?
Yes. One Azure tenant can contain repeated requests against the same customer case. GovernorAI keeps its cumulative limit, owner approval and evidence connected across agent sessions. The example above does not require another cloud or SaaS.
Could we build this with native Azure services?
You could assemble parts of it. Then your team owns the shared ledger, the approval lifecycle, policy rollout, coverage checks and evidence assembly, and keeps them working as Foundry, Entra and API Management change. GovernorAI brings those into one supported governance workflow. Start with one business case and compare control correctness, rule-change effort and evidence retrieval with your native implementation.
Why add GovernorAI if we already use Microsoft's controls?
Keep them. Add GovernorAI when you need a supported business-level workflow around those controls: shared case limits, approval holds, policy ownership, change continuity and decision-to-outcome evidence. Evaluate that complete workflow against your native implementation—not against an assumption that Microsoft lacks governance.
Does a new session give the agent a fresh business limit?
No. The governed limit follows the trusted business object and its time window. A new session or another authorized agent does not erase existing commitments. The production ledger must also handle concurrent requests, retries and uncertain execution results.
Does connecting our subscription change running agents?
No. Start with read-only discovery. Your team selects the runtime, gateway, or tool boundary where a policy will be enforced and reviews shadow-mode decisions before activating control.
Can a request wait for an approver before it reaches the business system?
Yes, on an integrated action path: the request is held before dispatch for a named approver. An approval records the decision and does not release the call; changed arguments or a new operation are a new request. Approval cannot override a hard business limit.
Do we have to replace API Management or our AI gateway?
No. Use your existing gateway as part of the governed path, or apply controls in your agent runtime and tool adapters. GovernorAI supplies the business decision while your existing identity, routing, and security controls remain in place.
What should we bring to the Azure briefing?
Bring one agent workflow that can change a system of record, the business rule it needs to follow, and its platform or security owner. We will map the integration, approval path, and evidence needed for a scoped evaluation.
Will governance slow down our agents?
Routine policy evaluation can run locally beside the agent. During your evaluation, measure the complete request path for your chosen runtime and gateway. See the published benchmark method ↗
Scoped evaluation
Your next Azure agent can do real work. Keep the authority yours.
Bring one Azure agent, one consequential action and the business rule it must follow. No second cloud. No platform migration. One scoped evaluation.
Continue
Govern EverywhereOne policy across your AI stack Runtime EnforcementDecide at the action boundary Policy & GovernanceOne policy, from intent to evidence Evidence & ComplianceHash-chained audit record, mapped to controls AWS BedrockInbound path, guardrail sync SecurityPer-call authorization and stop controls