Agent Governance Toolkit

Metti in produzione agenti senza perdere il sonno

🚀 Guida Rapida · 📋 Specifiche · 📦 PyPI · 📝 Registro delle modifiche

[!IMPORTANT] Anteprima Pubblica -- versioni di anteprima pubblica di qualità produzione. Potrebbero esserci modifiche sostanziali prima della GA.

Applicazione delle policy, identità, sandboxing e SRE per agenti AI autonomi. Un pip install, qualsiasi framework.

Il Problema

I tuoi agenti AI chiamano strumenti, navigano sul web, interrogano database e delegano ad altri agenti. Una volta distribuiti, prendono decisioni in modo autonomo. Hai bisogno di risposte a tre domande:

1. Questa azione è consentita? Un agente con accesso a send_email e query_database non dovrebbe essere in grado di drop_table. Gli ambiti OAuth e i ruoli IAM controllano a quali servizi un agente può arrivare, non cosa fa una volta connesso.

2. Quale agente ha fatto questo? In un sistema multi-agente, cinque agenti potrebbero condividere una singola chiave API. Quando qualcosa va storto, "è stato un agente" non è una risposta per la gestione degli incidenti.

3. Puoi provare cosa è successo? Revisori e regolatori necessitano di registrazioni a prova di manomissione di ogni decisione: quale policy era attiva, cosa ha richiesto l'agente e perché è stato consentito o negato.

La sicurezza a livello di prompt ("per favore segui le regole") non è una superficie di controllo. È una richiesta educata a un sistema stocastico. OWASP LLM01:2025 lo afferma esplicitamente: "non è chiaro se esistano metodi infallibili di prevenzione per l'iniezione di prompt." I dati pubblicati lo confermano. Andriushchenko et al. (ICLR 2025) riportano un tasso di successo degli attacchi del 100% su GPT-4o, GPT-3.5, Claude 3 e Llama-3 utilizzando attacchi adattivi con accesso ai logprob e ottimizzazione dei suffissi, valutati rispetto al benchmark JailbreakBench (Chao et al., NeurIPS 2024). L'AI Red Teaming Agent di Microsoft formalizza l'Attack Success Rate (ASR), il tasso di violazioni delle policy sotto input avversario, come metrica canonica per questa classe di fallimenti. Lessons from Red Teaming 100 Generative AI Products rafforza il punto: "le mitigazioni non eliminano completamente il rischio" e il red teaming deve essere un processo continuo perché le difese a livello di modello sono probabilistiche per costruzione.

AGT non cerca di vincere quella battaglia all'interno del prompt. Ogni chiamata a uno strumento, invio di messaggio e delega viene intercettata in codice applicativo deterministico prima che l'intento del modello raggiunga il filo. Le azioni che il kernel AGT nega non sono "improbabili". Sono strutturalmente impossibili. Questa è la differenza tra chiedere a un agente di comportarsi bene e renderlo incapace di comportarsi male.

Guida Rapida

Prerequisiti: Python 3.10+```bash pip install agent-governance-toolkit[full]

Per Claude Code, aggiungi AGT come marketplace di plugin e installa il plugin di governance:```text
/plugin marketplace add microsoft/agent-governance-toolkit
/plugin install agt-governance@agent-governance-toolkit

Governa qualsiasi funzione dello strumento in due righe:```python from agentmesh.governance import govern

safe_tool = govern(my_tool, policy="policy.yaml") # every call checked, logged, enforced

Tutto qui. `safe_tool` valuta la tua policy YAML a ogni chiamata, registra la decisione e solleva `GovernanceDenied` se l'azione è bloccata.```yaml
# policy.yaml
apiVersion: governance.toolkit/v1
name: production-policy
default_action: allow
rules:
  - name: block-destructive
    condition: "action.type in ['drop', 'delete', 'truncate']"
    action: deny
    description: "Destructive operations require human approval"

  - name: require-approval-for-send
    condition: "action.type == 'send_email'"
    action: require_approval
    approvers: ["security-team"]

Come di consueto, il flag di aiuto (-h) elenca tutti i sottocomandi disponibili per le variabili d'ambiente e i flag dell'applicazione.


$> pwnenv -h

``````python
>>> safe_tool(action="read", table="users")
{'table': 'users', 'rows': 42}

>>> safe_tool(action="drop", table="users")
GovernanceDenied: Action denied by policy rule 'block-destructive':
  Destructive operations require human approval

Oppure utilizza l'API completa PolicyEvaluator per il controllo programmatico:

PolicyEvaluator esempio

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

evaluator = PolicyEvaluator(policies=[PolicyDocument( name="my-policy", version="1.0", defaults=PolicyDefaults(action=PolicyAction.ALLOW), rules=[PolicyRule( name="block-dangerous-tools", condition=PolicyCondition( field="tool_name", operator=PolicyOperator.IN, value=["execute_code", "delete_file"] ), action=PolicyAction.DENY, priority=100, )], )])

result = evaluator.evaluate({"tool_name": "web_search"}) # Allowed result = evaluator.evaluate({"tool_name": "delete_file"}) # Blocked

</details>

<details>
<summary><b>TypeScript / .NET / Rust / Go esempi</b></summary>

**TypeScript**```typescript
import { PolicyEngine } from "@microsoft/agent-governance-sdk";

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

.NET```csharp 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**```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);

Go```go import agentmesh "github.com/microsoft/agent-governance-toolkit/agent-governance-golang"

client, _ := agentmesh.NewClient("my-agent", agentmesh.WithPolicyRules([]agentmesh.PolicyRule{ {Action: "data.read", Effect: agentmesh.Allow}, {Action: "*", Effect: agentmesh.Deny}, }), ) result := client.ExecuteWithGovernance("data.read", nil)

agent-governance-toolkit

Più Popolari

Come Funziona```