What is the difference between MAQPNA and the Microsoft Agent Governance Toolkit?
The Microsoft Agent Governance Toolkit (AGT) is an MIT-licensed, open-source set of libraries in Python, TypeScript, .NET, Rust and Go that adds policy checks, identity, audit, approvals and a kill switch inside your agent's application code. MAQPNA is a self-hosted runtime on Kubernetes that enforces the same kinds of controls outside the agent: each session runs in its own sandbox whose only network exit is the MAQPNA gateway, so a compromised or prompt-injected agent cannot skip the checks. Choose AGT if you want free, embeddable building blocks and are happy to assemble and operate them. Choose MAQPNA if you want enforcement the agent process cannot bypass, plus approvals, a ledger and air-gapped delivery as one product.
How do they compare side by side?
As of 1 November 2026, per the AGT repository, the AGT documentation and the MAQPNA docs.
| Microsoft Agent Governance Toolkit | MAQPNA | |
|---|---|---|
| Licence | MIT, open source | Proprietary, open core. The Community edition is free for one cluster, in production too (pricing) |
| Deployment model | Packages from PyPI, npm, NuGet, crates.io and Go modules that you import into the agent; plugins for several coding agents; deployment guides for Azure, AWS and Google Cloud | An operator, gateway and identity broker on your Kubernetes cluster, installed with Helm; maqpna dev on a laptop. Agents keep their framework and point their clients at the gateway |
| Where enforcement runs | "At the application middleware layer, not at the OS kernel level"; the README recommends a separate container per agent for OS-level isolation | In a separate gateway process; each session runs in a gVisor sandbox, a microVM or a confidential VM with default-deny egress except to the gateway (network and egress) |
| What it enforces | YAML policies with allow, deny and require_approval; OPA and Cedar support; an MCP security gateway class with deny lists, rate limits and response scanning; trust scoring; execution rings | Default-deny policy on every MCP tool call, model call, A2A call and egress connection, with rules on tools, arguments, users, groups, schedules and session taint; DLP; budgets; tool pinning (policies) |
| Approvals | A require_approval action resolved by your callback or webhook (for example to Slack or Teams); auto-denied after a timeout, 5 minutes by default (approval workflows) | Built-in approval requests bound to the exact arguments, four-eyes quorum, no self-approval, user approval on their own device (CIBA); decided in the CLI, console, Slack or Teams (approvals) |
| Audit | Tamper-evident decision records using a Merkle audit chain (audit and compliance) | A SHA-256 hash-chained ledger with signed checkpoints, verifiable offline, written by the gateway rather than the agent (audit ledger) |
| Kill switch | Yes, in the Agent SRE package (kill switch tutorial) | Yes: revoke an agent, session, user, token, namespace or everything, across gateway replicas (kill switch) |
| Air-gapped | Not addressed in the README; as libraries, the packages can be mirrored into an internal registry like any other dependency | Signed offline bundle, offline licence verification, no phone-home (air-gapped install) |
| Status | "Public Preview": "production-quality public preview releases. May have breaking changes before GA". Latest release v4.1.0, 9 June 2026 | Released; versions and signed artefacts on the download page |
| Maintained by | Microsoft, in the microsoft GitHub organisation; support terms in its SUPPORT.md | Kosa8 Labs, with paid support in the Team edition and above |
What is the Microsoft Agent Governance Toolkit?
AGT is a Microsoft open-source project for "policy enforcement, identity, sandboxing, and SRE for autonomous AI agents" (GitHub). It is built around a policy decision layer, the Agent Control Specification, which returns verdicts that the host application enforces. Its documentation lists several packages: Agent OS (policy, trust, identity and audit primitives), Agent Mesh (identity and agent-to-agent messaging), Agent Runtime (MCP and A2A governance), Agent Hypervisor (execution rings), Agent SRE (reliability, including the kill switch) and an MCP security gateway (docs). Python has the full feature set; the other language SDKs cover the core of policy, identity, trust and audit.
The project maps its controls to the OWASP Top 10 for Agentic Applications and to other frameworks. These mappings are self-reported, as are MAQPNA's in our own mapping.
Why does in-process vs out-of-process matter?
A library check runs in the same process as the agent, with the agent's privileges and credentials. That is fast and easy to adopt, and it catches honest mistakes well. The limit is that the code being governed can, in principle, reach around its own check: if the agent runs model-written code, holds an API key, or can open a network connection directly, a policy inside the process only governs the paths that go through it. AGT's own README says this plainly and recommends container isolation for OS-level boundaries.
An out-of-process gateway closes those paths with infrastructure instead of convention. In MAQPNA the sandbox's network policy allows traffic only to the gateway, upstream credentials live only in the gateway, and the agent holds a short-lived token that is useless anywhere else. The agent can ask; the gateway decides. The cost is that you run more infrastructure. See frameworks vs a runtime and what an MCP gateway does.
When should you choose the Agent Governance Toolkit instead?
- You want open source under MIT. You can read, fork and change every line. MAQPNA is proprietary.
- You are building agents in code and want governance close to them. AGT plugs into your application in five languages, without a cluster.
- You do not run Kubernetes. MAQPNA's production install needs a cluster. AGT needs only your application runtime.
- You are on Microsoft's stack. AGT has a .NET SDK and deployment guides for Azure Container Apps and Azure AI Foundry Agent Service.
- You want trust scoring or chaos testing for agents. These are part of AGT's documented scope; MAQPNA does not offer them.
- You want to assemble your own platform. AGT gives you primitives and lets you choose the approval channel, storage and operations around them.
When does MAQPNA fit?
- The agent must not be able to bypass the check. Default-deny egress and gateway-held credentials mean the only route out is through policy.
- Agents run code you did not review. Each session gets its own sandbox, from gVisor up to a confidential VM. See containers vs sandboxes.
- Approvals need separation of duties. Four-eyes quorum, no self-approval and single-use approvals bound to the arguments are built in. See human-in-the-loop approval.
- The evidence must not come from the agent. The gateway writes the ledger, so a compromised agent cannot edit its own record. See tamper-evident audit trails.
- You run air-gapped or sovereign. See sovereign and air-gapped agents.
The two can also be layered: an agent can keep in-process checks for fast feedback while its calls still pass through the MAQPNA gateway for enforcement. MAQPNA has no integration with AGT today, so this is an architecture option, not a supported combination.