🚀 10-Minute Quick Start Guide¶

graph LR
    A[AI Agent] -->|Tool Call| B{Governance Layer}
    B -->|Policy Check| C{PolicyEngine}
    C -->|Allowed| D[Execute Tool]
    C -->|Blocked| E[Security Block]
    D --> F[Audit Log]
    E --> F
    F --> G[OTEL / Structured Logs]

pip install agent-governance-toolkit[full]

pip install agent-os-kernel        # Policy enforcement + framework integrations
pip install agentmesh-platform     # Zero-trust identity + trust cards
pip install agent-governance-toolkit    # OWASP ASI verification + integrity CLI
pip install agent-sre              # SLOs, error budgets, chaos testing
pip install agentmesh-runtime       # Execution supervisor + privilege rings
pip install agentmesh-marketplace      # Plugin lifecycle management
pip install agentmesh-lightning        # RL training governance

npm install @microsoft/agent-governance-sdk

dotnet add package Microsoft.AgentGovernance

python scripts/check_gov.py

agt verify
agt verify --badge

from agent_os.policies import PolicyEvaluator
from agent_os.policies.schema import (
    PolicyDocument, PolicyRule, PolicyCondition,
    PolicyAction, PolicyOperator, PolicyDefaults,
)

# --- Step 1: Define your agent's tools ---

def web_search(query: str) -> str:
    """Simulated web search tool."""
    return f"Results for: {query}"

def delete_file(path: str) -> str:
    """Dangerous tool — should be blocked by policy."""
    return f"Deleted: {path}"

TOOLS = {
    "web_search": web_search,
    "delete_file": delete_file,
}

# --- Step 2: Define governance policies ---

policy = PolicyDocument(
    name="agent-safety",
    version="1.0",
    description="Safety policy for the research agent",
    defaults=PolicyDefaults(action=PolicyAction.ALLOW),
    rules=[
        PolicyRule(
            name="block-dangerous-tools",
            condition=PolicyCondition(
                field="tool_name",
                operator=PolicyOperator.IN,
                value=["delete_file", "shell_exec", "execute_code"],
            ),
            action=PolicyAction.DENY,
            message="Tool is blocked by safety policy",
            priority=100,
        ),
        PolicyRule(
            name="block-ssn-patterns",
            condition=PolicyCondition(
                field="input_text",
                operator=PolicyOperator.MATCHES,
                value=r"\b\d{3}-\d{2}-\d{4}\b",
            ),
            action=PolicyAction.DENY,
            message="SSN pattern detected — blocked",
            priority=90,
        ),
    ],
)

evaluator = PolicyEvaluator(policies=[policy])

# --- Step 3: Build a governed agent ---

class GovernedAgent:
    """A simple agent that checks policy before every tool call."""

    def __init__(self, name, tools, evaluator):
        self.name = name
        self.tools = tools
        self.evaluator = evaluator

    def call_tool(self, tool_name: str, params: dict) -> str:
        # Policy check BEFORE execution
        decision = self.evaluator.evaluate({
            "tool_name": tool_name,
            "input_text": str(params),
            "agent_id": self.name,
        })

        if not decision.allowed:
            print(f"  ✗ BLOCKED: {decision.reason}")
            return f"[BLOCKED] {decision.reason}"

        # Execute the tool
        print(f"  ✓ ALLOWED: {tool_name}")
        tool_fn = self.tools[tool_name]
        return tool_fn(**params)

# --- Step 4: Run it ---

agent = GovernedAgent("research-agent", TOOLS, evaluator)

print("Agent: searching the web...")
result = agent.call_tool("web_search", {"query": "latest AI governance news"})
print(f"  Result: {result}\n")

print("Agent: trying to delete a file...")
result = agent.call_tool("delete_file", {"path": "/etc/passwd"})
print(f"  Result: {result}\n")

print("Agent: searching with SSN in query...")
result = agent.call_tool("web_search", {"query": "lookup 123-45-6789"})
print(f"  Result: {result}")

python governed_agent.py

Agent: searching the web...
  ✓ ALLOWED: web_search
  Result: Results for: latest AI governance news

Agent: trying to delete a file...
  ✗ BLOCKED: Tool is blocked by safety policy
  Result: [BLOCKED] Tool is blocked by safety policy

Agent: searching with SSN in query...
  ✗ BLOCKED: SSN pattern detected — blocked
  Result: [BLOCKED] SSN pattern detected — blocked

from agent_os.policies import PolicyEvaluator

evaluator = PolicyEvaluator()
evaluator.load_policies("policies/")   # loads all *.yaml files

result = evaluator.evaluate({"tool_name": "web_search", "agent_id": "analyst-1"})
print(f"Allowed: {result.allowed}")

import { PolicyEngine, AgentIdentity, AuditLogger } from "@microsoft/agent-governance-sdk";

const identity = AgentIdentity.generate("my-agent", ["web_search", "read_file"]);

const engine = new PolicyEngine([
  { action: "web_search", effect: "allow" },
  { action: "delete_file", effect: "deny" },
]);

console.log(engine.evaluate("web_search"));  // "allow"
console.log(engine.evaluate("delete_file")); // "deny"

using AgentGovernance;
using AgentGovernance.Policy;

var kernel = new GovernanceKernel(new GovernanceOptions
{
    PolicyPaths = new() { "policies/default.yaml" },
    EnablePromptInjectionDetection = true,
});

var result = kernel.EvaluateToolCall("did:mesh:agent-1", "web_search", new() { ["query"] = "AI news" });
Console.WriteLine($"Allowed: {result.Allowed}");  // True (if policy permits)

result = kernel.EvaluateToolCall("did:mesh:agent-1", "delete_file", new() { ["path"] = "/etc/passwd" });
Console.WriteLine($"Allowed: {result.Allowed}");  // False

from agent_os.policies import PolicyEvaluator

# Load your governance policies
evaluator = PolicyEvaluator()
evaluator.load_policies("policies/")

# Evaluate before every tool call in your framework
decision = evaluator.evaluate({
    "agent_id": "langchain-agent-1",
    "tool_name": "web_search",
    "action": "tool_call",
})

if decision.allowed:
    # proceed with LangChain tool call
    result = your_langchain_agent.run(...)
else:
    print(f"Blocked: {decision.reason}")

pip install langchain-agentmesh      # LangChain adapter
pip install llamaindex-agentmesh     # LlamaIndex adapter
pip install crewai-agentmesh         # CrewAI adapter

# Text summary
agt verify

# JSON for CI/CD pipelines
agt verify --json

# Badge for your README
agt verify --badge

{
  "status": "error",
  "message": "An internal error occurred during verification",
  "type": "InternalError"
}

# Generate a baseline integrity manifest
agt integrity --generate integrity.json

# Verify against the manifest later
agt integrity --manifest integrity.json