Snapshot of microsoft/agent-governance-toolkit: 6.6k★, Python, Backend. AI Agent Governance Toolkit — Policy enforcement, zero-trust identity, execution sandboxing, and reliability engineering for autonomous AI agents. Covers 10/10 OWASP Agentic Top 10.
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
Policy enforcement, identity, sandboxing, and SRE for autonomous AI agents. One pip install, any framework.
The Problem
Your AI agents call tools, browse the web, query databases, and delegate to other agents. Once deployed, they make decisions autonomously. You need answers to three questions:
1. Is this action allowed? An agent with access to send_email and query_database should not be able to drop_table. OAuth scopes and IAM roles control which services an agent can reach, not what it does once connected.
2. Which agent did this? In a multi-agent system, five agents might share a single API key. When something goes wrong, "an agent did it" is not an incident response.
3. Can you prove what happened? Auditors and regulators need tamper-evident records of every decision: what policy was active, what the agent requested, and why it was allowed or denied.
Prompt-level safety ("please follow the rules") is not a control surface. It is a polite request to a stochastic system. OWASP LLM01:2025 states this explicitly: "it is unclear if there are fool-proof methods of prevention for prompt injection." The published numbers back this up. Andriushchenko et al. (ICLR 2025) report 100% attack success rate on GPT-4o, GPT-3.5, Claude 3, and Llama-3 using adaptive attacks with logprob access and suffix optimization, evaluated against the JailbreakBench benchmark (Chao et al., NeurIPS 2024). Microsoft's own AI Red Teaming Agent formalizes Attack Success Rate (ASR), the rate of policy violations under adversarial input, as the canonical metric for this class of failure. Lessons from Red Teaming 100 Generative AI Products reinforces the point: "mitigations do not eliminate risk entirely" and red teaming must be a continuous process because model-layer defenses are probabilistic by construction.
AGT does not try to win that fight inside the prompt. Every tool call, message send, and delegation is intercepted in deterministic application code before the model's intent reaches the wire. Actions the AGT kernel denies are not "unlikely." They are structurally impossible. That is the difference between asking an agent to behave and making it incapable of misbehaving.
Quick Start
Prerequisites: Python 3.11+
pip install "agent-governance-toolkit[full]"
Use the [full] extra for the quick-start imports below. The base
agent-governance-toolkit wheel installs the compliance CLI only; the governance
modules live in the consolidated core distribution. The agentmesh quick-start
import remains the current wrapper API. Importing agent_os emits a
DeprecationWarning because the old agent-os-kernel distribution is deprecated.
Use agent-governance-toolkit-core (or the [full] extra that includes it) as
the replacement distribution. Policy-engine host code uses the ACS SDK;
agt-policies provides the one-way v4-to-v5 migration command. The pre-ACS
agent_os.policies rule model is gone, and BREAKING_CHANGES.md lists its
replacements.
The policy engine is published upstream as
agent-control-spec.
agent-hooks defines its
interception contract. AGT retains the AgentControl host APIs and framework
adapters in policy-engine/, not a second decision engine.
This keeps policy evaluation in one place. AGT can adopt upstream fixes through
a dependency update while keeping its host APIs and framework integrations.
See the ACS package guide for
the distinction between upstream packages and AGT's compatibility SDKs.
For Claude Code, add AGT as a plugin marketplace and install the governance plugin:
from agentmesh.governance import govern
safe_tool = govern(my_tool, policy="policy.yaml") # every call checked, logged, enforced
On every call, safe_tool evaluates the YAML policy, logs the decision to an
audit trail, and raises GovernanceDenied when the policy blocks the action.
using AgentGovernance;
using AgentGovernance.Extensions.ModelContextProtocol;
using AgentGovernance.Policy;
var kernel = new GovernanceKernel(new GovernanceOptions
{
PolicyPaths = new() { "policies/default.yaml" },
});
var result = kernel.EvaluateToolCall("did:mesh:agent-1", "web_search",
new() { ["query"] = "latest AI news" });
// MCP server integration
builder.Services.AddMcpServer()
.WithGovernance(options => options.PolicyPaths.Add("policies/mcp.yaml"));
Rust
use agent_governance::{AgentMeshClient, ClientOptions};
let client = AgentMeshClient::new("my-agent").unwrap();
let result = client.execute_with_governance("data.read", None);
assert!(result.allowed);
Every layer is optional. Start with govern() and add layers as your risk profile grows. Most teams run policy enforcement + audit logging and never need the full stack.
go get github.com/microsoft/agent-governance-toolkit/agent-governance-golang
All five language SDKs implement core governance (policy, identity, trust, audit). Python has the full stack. Copilot CLI and Claude Code are first-party developer surfaces built on the TypeScript SDK.
See Language Package Matrix for detailed per-language coverage.
Python distributions (v4.1.0 — consolidated)
As of v4.1.0, 45 packages have been consolidated into 5 top-level distributions:
Previous package names (agent-os-kernel, agentmesh-platform, agentmesh-runtime, agent-sre, agent-discovery, agent-hypervisor, agentmesh-marketplace, agentmesh-lightning) remain installable as stub packages that redirect to the consolidated distributions.
Prerequisites
Python: 3.10+
Node.js: 18+ / npm 9+ (TypeScript SDK)
.NET: 8+
Go: 1.25+
Rust: 1.70+
Optional: AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET for Azure-integrated features
Framework Support
Framework
Integration
Microsoft Agent Framework
Native Middleware
Semantic Kernel
Native (.NET + Python)
AutoGen
Adapter
LangGraph / LangChain
Adapter
CrewAI
Adapter
OpenAI Agents SDK
Middleware
Claude Code
Governance plugin package
Google ADK
Adapter
LlamaIndex
Middleware
Haystack
Pipeline
Mastra
Adapter
Dify
Plugin
Azure AI Foundry
Deployment Guide
GitHub Copilot CLI
Governance installer
Full list: Framework Integrations · Quickstart Examples
Examples
Example
Framework
What it demonstrates
acs-email-tool
Framework-neutral ACS host
Snapshot, verdict, transform, deny, and host enforcement
acs-atr-annotator
ACS custom policy
Independent threat-rule annotations with fail-closed decisions
openai-agents-governed
OpenAI Agents SDK
Policy-gated tool calls with trust tiers
crewai-governed
CrewAI
Multi-agent governance with role-based policies
smolagents-governed
HuggingFace smolagents
Lightweight agent governance
maf-integration
MAF
Microsoft Agent Framework integration
mcp-trust-verified-server
MCP
Trust-verified MCP server implementation
governance-dashboard
Streamlit
Real-time fleet visibility dashboard
k8s-agent-sandbox-governed
kubernetes-sigs/agent-sandbox
Pre-dispatch command policy on top of Kubernetes-native execution isolation
Specifications
Every major component has a formal RFC 2119 specification with conformance tests. These specs define the behavioral contract: what implementations MUST, SHOULD, and MAY do.
Specification
Scope
Tests
Agent OS Policy Engine
Native runtime integration and fail-closed semantics
992 conformance tests ensure code stays aligned to specs. 29 Architecture Decision Records document why.
Standards Compliance
Standard
Coverage
OWASP Agentic AI Top 10
All ASI risk categories mapped with deterministic controls
NIST AI RMF 1.0
Full GOVERN, MAP, MEASURE, MANAGE alignment
EU AI Act
Compliance mapping with automated evidence
SOC 2
Control mapping with audit trail export
AARM Extended
All R1–R9 requirements satisfied; verified Jun 14, 2026
ATF
All five elements mapped: Agent Mesh (identity), Agent OS (policy), Agent Compliance (governance), Agent Runtime (sandboxing), Agent SRE (incident response)
Security
AGT enforces governance at the application middleware layer, not at the OS kernel level. The policy engine and agents share the same process boundary.
Production recommendation: Run each agent in a separate container for OS-level isolation. See Architecture: Security Boundaries.
If you use the Agent Governance Toolkit to build applications that operate with third-party agent frameworks or services, you do so at your own risk. We recommend reviewing all data being shared with third-party services and being cognizant of third-party practices for retention and location of data.
Official Sources
The only official sources for the Agent Governance Toolkit are:
Resource
Location
Source code
github.com/microsoft/agent-governance-toolkit
Documentation
microsoft.github.io/agent-governance-toolkit
Python packages
https://pypi.org/user/agentgovtoolkit/
npm packages
@microsoft/agent-governance-sdk on npmjs.com
NuGet packages
Microsoft.AgentGovernance.* on nuget.org
Rust crates
agent-governance, agent-governance-mcp on crates.io
The project team does not maintain or endorse any third-party websites,
packages, or documentation sites claiming to be official. If you encounter a
suspicious site or package using the Agent Governance Toolkit name, please
report it through the channels described in SECURITY.md.
License
This project is licensed under the MIT License.
Trademarks
This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
trademarks or logos is subject to and must follow
Microsoft's Trademark & Brand Guidelines.
Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
Any use of third-party trademarks or logos are subject to those third-party's policies.
How active is development on microsoft/agent-governance-toolkit?
The most recent commit recorded on microsoft/agent-governance-toolkit was 2 months ago, based on the GitHub push timestamp. The repository has 1.1k forks — one of the better signals of community interest.
How does microsoft/agent-governance-toolkit compare to other Backend projects?
microsoft/agent-governance-toolkit is tracked by TopGit in the Backend category, with 6.6k GitHub stars and written in Python. Browse the Backend topic page on TopGit to compare it against similar projects by stars and activity.
How many stars does microsoft/agent-governance-toolkit have?
microsoft/agent-governance-toolkit has 6.6k GitHub stars — refresh the page for the live number, or check github.com/microsoft/agent-governance-toolkit. TopGit mirrors GitHub's count but does not claim minute-by-minute accuracy.
What is microsoft/agent-governance-toolkit?
microsoft/agent-governance-toolkit (microsoft/agent-governance-toolkit) is a Python project on GitHub. From the project's own README: AI Agent Governance Toolkit — Policy enforcement, zero-trust identity, execution sandboxing, and reliability engineering for autonomous AI agents. Covers 10/10 OWASP Agentic Top 10.
What language is microsoft/agent-governance-toolkit written in?
microsoft/agent-governance-toolkit is written primarily in Python. GitHub's language field is based on the largest share of bytes in the default branch.
What topics is microsoft/agent-governance-toolkit associated with?
Why is microsoft/agent-governance-toolkit categorized under Backend?
TopGit places microsoft/agent-governance-toolkit in the Backend category based on its GitHub topics and description (tagged: "agent-framework", "ai-agents", "ai-safety"). Categories are assigned from real repository metadata, not editorial guesswork.
Read full README in the tab above.
Curious whether agent-governance-toolkit is right for you?
Let ChatGPT, Claude, or Perplexity look into it — click below and see what AI actually says about agent-governance-toolkit.