Microsoft Agent Governance Toolkit

Microsoft Agent Governance Toolkit

Indice

1. Cos’è l’Agent Governance Toolkit e perché interessa ora
2. A cosa serve: casi d’uso reali (e quando NON usarlo)
3. Requisiti hardware e software
4. Installazione passo dopo passo
5. Come avviare il kernel e fare le prime chiamate
6. Caso d’uso pratico: governare un agente di supporto interno su Azure App Service
7. Conclusioni e formazione professionale

Microsoft ha rilasciato l’Agent Governance Toolkit (AGT), un set di librerie open source per controllare cosa possono fare davvero gli agenti AI in produzione — non a livello di prompt, ma di codice applicativo. Per chi sviluppa in .NET, il pacchetto Microsoft.AgentGovernance porta policy enforcement, identità zero-trust e audit log direttamente dentro la pipeline di un’app ASP.NET Core o di un agente basato su Microsoft Agent Framework.

1. Cos’è l’Agent Governance Toolkit e perché interessa ora

Gli agenti AI autonomi non si limitano più a rispondere a domande: chiamano tool, interrogano database, inviano email, delegano compiti ad altri agenti. Il problema è che le protezioni classiche (scope OAuth, ruoli IAM) controllano a quali servizi un agente può connettersi, non cosa fa una volta connesso. Un agente con accesso a send_email e query_database non dovrebbe poter eseguire drop_table, ma nulla glielo impedisce a livello di infrastruttura.

L’Agent Governance Toolkit nasce per chiudere questo buco. Intercetta ogni chiamata a tool, ogni invio di messaggio, ogni delega tra agenti in codice applicativo deterministico, prima che l’intento del modello arrivi a eseguirsi davvero. La differenza è sostanziale: chiedere a un modello di comportarsi bene è una richiesta probabilistica, mentre bloccare un’azione nel kernel di governance è strutturalmente impossibile da aggirare con un prompt injection.

Pensa al firewall applicativo che mettevi davanti a una API REST per validare i payload prima che arrivassero al database: AGT fa lo stesso lavoro, ma per le azioni di un agente AI. La policy decide, il kernel applica, l’audit log registra — indipendentemente da cosa il modello “pensa” di voler fare.

Il progetto è MIT-licensed, attualmente in Public Preview con release firmate Microsoft, e copre tutte le 10 categorie dell’OWASP Agentic AI Top 10. È disponibile in Python, TypeScript, .NET, Go e Rust, con integrazioni native per Microsoft Agent Framework, Semantic Kernel, LangChain, CrewAI e altri.

2. A cosa serve: casi d’uso reali (e quando NON usarlo) – Microsoft Agent Governance Toolkit

AGT risponde a tre domande operative che ogni team che porta agenti in produzione deve poter rispondere:

• questa azione è permessa?
• Quale agente l’ha eseguita?
• Posso dimostrare cosa è successo, con un audit tamper-evident, davanti a un auditor?

I casi d’uso concreti per uno sviluppatore .NET sono tre. Primo: governare un server MCP (Model Context Protocol) costruito con l’SDK ufficiale C#, bloccando tool poisoning, drift di configurazione e istruzioni nascoste nei tool prima che vengano esposti al modello. Secondo: applicare policy di autorizzazione granulari su agenti costruiti con Microsoft Agent Framework o Semantic Kernel, ad esempio impedendo operazioni distruttive senza approvazione umana. Terzo: produrre audit log firmati e mappati su standard come SOC 2, NIST AI RMF ed EU AI Act, utili in contesti regolamentati come finance e sanità.

Quando NON ha senso usarlo: se il tuo “agente” è in realtà una singola chiamata a un LLM senza tool use, o se sei in fase di prototipo puro senza dati o azioni sensibili. AGT aggiunge un livello di enforcement che ha senso quando l’agente esegue azioni reali con conseguenze reali — non quando genera solo testo.

3. Requisiti hardware e software

Per il SDK .NET non servono requisiti hardware particolari: l’enforcement avviene a livello applicativo, non richiede GPU né infrastrutture dedicate. I requisiti software sono questi:

• .NET 8.0 o superiore (target runtime del pacchetto)
• NuGet: Microsoft.AgentGovernance (attualmente in versione 2.1.0), con un’unica dipendenza esterna, YamlDotNet, usata per il parsing delle policy
• Per integrare un server MCP basato sull’SDK ufficiale C#: pacchetto aggiuntivo Microsoft.AgentGovernance.Extensions.ModelContextProtocol
• Per agenti costruiti con il vero Microsoft Agent Framework (Microsoft.Agents.AI): pacchetto Microsoft.AgentGovernance.Extensions.Microsoft.Agents
• Opzionale: variabili AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET se vuoi usare le funzionalità integrate con Azure

Microsoft consiglia inoltre, in produzione, di eseguire ogni agente in un container separato: il kernel di governance e l’agente condividono lo stesso processo, quindi l’isolamento a livello di sistema operativo resta una responsabilità tua, non del toolkit.

4. Installazione passo dopo passo

Apri il terminale nella cartella del tuo progetto .csproj e installa il pacchetto base:

dotnet add package Microsoft.AgentGovernance

Se il tuo progetto non è nella cartella corrente, specifica il percorso esplicitamente:

dotnet add YourApp.csproj package Microsoft.AgentGovernance

Se lavori con Visual Studio e Package Manager Console, usa Install-Package assicurandoti che il progetto giusto sia selezionato nel menu a tendina “Default project” — digitare solo il nome del pacchetto al prompt fallisce, perché PowerShell lo interpreta come un comando.

Se devi governare un server MCP costruito con l’SDK ufficiale, aggiungi anche:

dotnet add package Microsoft.AgentGovernance.Extensions.ModelContextProtocol

A questo punto crea il file di policy. È YAML, dichiarativo, e definisce regole di allow/deny/require_approval valutate ad ogni chiamata:

# policies/default.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: "Le operazioni distruttive richiedono approvazione umana"

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

5. Come avviare il kernel e fare le prime chiamate

Il punto di ingresso del SDK .NET è la classe GovernanceKernel. La crei una volta, le passi le policy, e da quel momento ogni chiamata a tool dell’agente passa da lì prima di essere eseguita:

using AgentGovernance;
using AgentGovernance.Policy;

// Creiamo il kernel caricando la policy YAML definita sopra
// ConflictStrategy.DenyOverrides: se due regole sono in conflitto, vince il deny
var kernel = new GovernanceKernel(new GovernanceOptions
{
    PolicyPaths = new() { "policies/default.yaml" },
    ConflictStrategy = ConflictResolutionStrategy.DenyOverrides,
    EnableRings = true,                      // attiva l'enforcement dei privilege ring
    EnablePromptInjectionDetection = true,    // scansiona gli input alla ricerca di injection
    EnableCircuitBreaker = true,              // resilienza sulle valutazioni di governance
});

// Valutiamo una chiamata a tool PRIMA di eseguirla davvero
var result = kernel.EvaluateToolCall(
    agentId: "did:mesh:analyst-001",
    toolName: "file_write",
    args: new() { ["path"] = "/etc/config" }
);

if (!result.Allowed)
{
    // L'azione è bloccata in modo deterministico, non "probabilmente" bloccata
    Console.WriteLine($"Bloccato: {result.Reason}");
}
else
{
    // Solo qui eseguiamo davvero il tool, con gli argomenti eventualmente sanificati
    await EseguiToolAsync(toolName: "file_write", args: result.SanitizedArgs);
}

Se stai esponendo un server MCP con l’SDK ufficiale C#, l’integrazione è ancora più diretta: un solo metodo builder aggancia governance su tutto il ciclo di vita del tool, dalla scansione dei tool prima di esporli fino alla sanificazione della risposta:

using AgentGovernance.Extensions.ModelContextProtocol;

// Un'unica chiamata registra controlli di startup e runtime sul server MCP:
// scansione dei tool, enforcement basato su identità, audit e metriche
builder.Services.AddMcpServer()
    .WithGovernance(options => options.PolicyPaths.Add("policies/mcp.yaml"));

Per validare l’installazione e la configurazione, il toolkit espone una CLI (agt) condivisa tra i linguaggi, utile anche in pipeline CI/CD .NET:

agt doctor                                         # verifica l'installazione
agt verify --evidence ./agt-evidence.json --strict  # blocca la CI se l'evidenza è debole
agt lint-policy policies/                           # valida i file di policy YAML

6. Caso d’uso pratico: governare un agente di supporto interno su Azure App Service

Immagina un team .NET che ha costruito, con Microsoft Agent Framework, un agente di supporto interno che legge ticket, interroga un database clienti e può inviare email di follow-up, deployato su Azure App Service. Senza governance, un prompt injection in un ticket potrebbe in teoria spingere l’agente a eseguire query non autorizzate o inviare email a destinatari sbagliati.

L’integrazione, come riportato da Microsoft in un caso reale su un travel planner multi-agente costruito con Microsoft Agent Framework 1.0, ha richiesto circa 30 minuti e un solo file nuovo: governance-policies.yaml nella root del progetto. Il team ha attivato tre pacchetti in combinazione: Agent OS, il motore di policy che intercetta e valuta ogni azione; Agent Compliance, per la mappatura regolamentare e la generazione automatica delle audit trail; Agent SRE, per SLO ed error budget sull’affidabilità dell’agente.

Tradotto in pratica per lo scenario del supporto interno: una regola deny blocca query SQL con DELETE o DROP senza approvazione; una regola require_approval instrada ogni invio email verso un canale di review; il kernel registra ogni decisione in un audit log a prova di manomissione, già mappato su SOC 2 e NIST AI RMF, pronto da esportare per un auditor senza lavoro aggiuntivo.

7. Conclusioni e formazione professionale

L’Agent Governance Toolkit dimostra una cosa che chi lavora con agenti AI in produzione sa già per esperienza: la sicurezza non si ottiene scrivendo un prompt più educato, ma progettando un’architettura che renda certe azioni strutturalmente impossibili. Per un team .NET questo significa imparare a integrare GovernanceKernel, policy YAML, ring di privilegio e audit trail nello stesso modo in cui oggi si integra autenticazione o logging — come parte dell’architettura, non come ripensamento dell’ultimo minuto.

Per questo, se la tua azienda vuole accelerare l’adozione consapevole degli strumenti di AI Generativa nel reparto tecnico, ti consigliamo i Corsi AI Generativa di Innovaformazione, pensati appositamente per team IT e sviluppatori .NET che devono portare agenti AI in produzione in sicurezza.

I corsi sono erogati in modalità online classe virtuale, con calendario concordabile con la tua organizzazione e un preventivo dedicato in base alle esigenze specifiche del team. È possibile accedere a finanziamenti tramite Fondimpresa o altri fondi interprofessionali, con supporto nella predisposizione del piano formativo finanziato.

Per richiedere informazioni o un preventivo:

📧 info@innovaformazione.net 📞 347 101 2275 — Dario Carrassi

(fonte) (fonte) (fonte) (fonte)