🌍 English | 日本語 | 简体中文 | 한국어

Agent Governance Toolkit

Déployez des agents en production sans perdre le sommeil

🚀 Démarrage rapide · 📋 Spécifications · 📦 PyPI · 📝 Changelog

[!IMPORTANT] Aperçu public — versions d’aperçu public de qualité production. Des changements cassants sont possibles avant la disponibilité générale.

Application des politiques, identité, sandboxing et SRE pour agents IA autonomes. Un seul pip install, n’importe quel framework.

Le problème

Vos agents IA appellent des outils, naviguent sur le web, interrogent des bases de données et délèguent à d’autres agents. Une fois déployés, ils prennent des décisions de manière autonome. Vous avez besoin de réponses à trois questions :

1. Cette action est-elle autorisée ? Un agent ayant accès à send_email et query_database ne devrait pas pouvoir drop_table. Les portées OAuth et les rôles IAM contrôlent les services qu’un agent peut atteindre, pas ce qu’il fait une fois connecté.

2. Quel agent a fait cela ? Dans un système multi-agent, cinq agents peuvent partager une seule clé API. Quand quelque chose tourne mal, « un agent l’a fait » n’est pas une réponse pour l’incident.

3. Pouvez-vous prouver ce qui s’est passé ? Les auditeurs et les autorités de régulation ont besoin d’enregistrements infalsifiables de chaque décision : quelle politique était active, ce que l’agent a demandé, et pourquoi cela a été autorisé ou refusé.

La sécurité au niveau des invites (« veuillez suivre les règles ») n’est pas une surface de contrôle. C’est une demande polie à un système stochastique. OWASP LLM01:2025 le dit explicitement : « il n’est pas clair s’il existe des méthodes infaillibles de prévention contre l’injection d’invites. » Les chiffres publiés le confirment. Andriushchenko et al. (ICLR 2025) rapportent un taux de succès d’attaque de 100 % sur GPT-4o, GPT-3.5, Claude 3 et Llama-3 en utilisant des attaques adaptatives avec accès aux logprobs et optimisation de suffixe, évaluées via le benchmark JailbreakBench (Chao et al., NeurIPS 2024). L’Agent de cybersécurité IA de Microsoft formalise le taux de succès d’attaque (ASR), le taux de violations de politique sous entrée adverse, comme la métrique canonique pour cette classe de défaillances. Leçons tirées de la cybersécurité de 100 produits d’IA générative renforce le point : « les mesures d’atténuation n’éliminent pas complètement le risque » et la cybersécurité doit être un processus continu car les défenses au niveau du modèle sont probabilistes par construction.

AGT ne tente pas de gagner cette bataille à l’intérieur de l’invite. Chaque appel d’outil, chaque envoi de message et chaque délégation est intercepté dans le code applicatif déterministe avant que l’intention du modèle n’atteigne le réseau. Les actions que le noyau AGT refuse ne sont pas « improbables ». Elles sont structurellement impossibles. C’est la différence entre demander à un agent de bien se comporter et le rendre incapable de mal se comporter.

Démarrage rapide

Prérequis : Python 3.10+```bash pip install agent-governance-toolkit[full]

Pour Claude Code, ajoutez AGT comme marketplace de plugins et installez le plugin de gouvernance :```text
/plugin marketplace add microsoft/agent-governance-toolkit
/plugin install agt-governance@agent-governance-toolkit

Gérer n'importe quelle fonction d'outil en deux lignes :```python from agentmesh.governance import govern

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

C'est tout. `safe_tool` évalue votre politique YAML à chaque appel, enregistre la décision et lève `GovernanceDenied` si l'action est bloquée.```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"]

Please provide the Markdown content to translate.```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

Ou utilisez l'API complète `PolicyEvaluator` pour un contrôle programmatique :

<details>
<summary><b>Exemple de PolicyEvaluator</b></summary>```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

**.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"));

**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)

Outils CLI:```bash agt doctor # check installation agt verify # OWASP compliance check agt verify --evidence ./agt-evidence.json --strict # fail CI on weak evidence agt red-team scan ./prompts/ --min-grade B # prompt injection audit agt lint-policy policies/ # validate policy files

Full walkthrough: [quickstart.md](https://github.com/microsoft/agent-governance-toolkit/blob/HEAD/docs/quickstart.md) -- de zéro à des agents gouvernés en 5 minutes.
🌍 Aussi en: [日本語](https://github.com/microsoft/agent-governance-toolkit/blob/HEAD/docs/i18n/quickstart.ja.md) | [简体中文](https://github.com/microsoft/agent-governance-toolkit/blob/HEAD/docs/i18n/quickstart.zh-CN.md) | [한국어](https://github.com/microsoft/agent-governance-toolkit/blob/HEAD/docs/i18n/quickstart.ko.md)

---

## Comment ça marche```
Agent ──► Policy Engine ──► Identity ──► Audit Log
            (YAML/OPA/Cedar)  (SPIFFE/DID/mTLS)  (Tamper-evident)
                 │                                      │
                 ├── Allowed ──► Tool executes           │
                 └── Denied  ──► GovernanceDenied        │
                                                        ▼
                                                 Decision Record

Chaque couche est optionnelle. Commencez par govern() et ajoutez des couches à mesure que votre profil de risque évolue. La plupart des équipes utilisent l'application des politiques + la journalisation d'audit et n'ont jamais besoin de la pile complète.

Paquets

Capacités supplémentaires

Installation

Les cinq SDK de langage implémentent la gouvernance de base (politiques, identité, confiance, audit). Python dispose de la pile complète. Copilot CLI et Claude Code sont des surfaces développeur de première partie construites sur le SDK TypeScript. Voir Matrice des fonctionnalités par langage pour une couverture détaillée par langage.

Prérequis

• Python : 3.10+
• Node.js : 18+ / npm 9+ (SDK TypeScript)
• .NET : 8+
• Go : 1.25+
• Rust : 1.70+
• Optionnel : AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_CLIENT_SECRET pour les fonctionnalités intégrées à Azure

Prise en charge des frameworks

Liste complète : Intégrations de frameworks · Exemples de démarrage rapide

Exemples

Spécifications

Chaque composant majeur dispose d'une spécification formelle RFC 2119 avec des tests de conformité. Ces spécifications définissent le contrat comportemental : ce que les implémentations DOIVENT, DEVRAIENT et PEUVENT faire.

992 tests de conformité garantissent que le code reste aligné sur les spécifications. 29 enregistrements de décisions d'architecture documentent pourquoi.

Conformité aux normes

Sécurité

AGT applique la gouvernance au niveau middleware de l'application, pas au niveau noyau du système d'exploitation. Le moteur de politiques et les agents partagent la même limite de processus.

Recommandation de production : Exécutez chaque agent dans un conteneur séparé pour une isolation au niveau OS. Voir Architecture : Limites de sécurité.

Voir Limitations connues pour les limites de conception honnêtes et la défense en couches recommandée.

Documentation

Contribution

Guide de contribution · Communauté · Discord · Politique de sécurité · Journal des modifications

Vous utilisez AGT ? Ajoutez votre organisation à ADOPTERS.md.

Gouvernance

Notes importantes

Si vous utilisez Agent Governance Toolkit pour créer des applications qui fonctionnent avec des frameworks ou services d'agents tiers, vous le faites à vos propres risques. Nous vous recommandons de passer en revue toutes les données partagées avec des services tiers et de tenir compte des pratiques des tiers en matière de conservation et de localisation des données.

Sources officielles

Les seules sources officielles d'Agent Governance Toolkit sont :

L'équipe du projet ne maintient ni n'approuve aucun site web, paquet ou site de documentation tiers se présentant comme officiel. Si vous rencontrez un site ou un paquet suspect utilisant le nom Agent Governance Toolkit, veuillez le signaler via les canaux décrits dans SECURITY.md.

Licence

Ce projet est sous licence MIT.

Marques déposées

Ce projet peut contenir des marques ou logos pour des projets, produits ou services. L'utilisation autorisée des marques ou logos de Microsoft est soumise et doit suivre les Directives sur les marques et la marque de Microsoft. L'utilisation des marques ou logos de Microsoft dans des versions modifiées de ce projet ne doit pas créer de confusion ni suggérer un parrainage de Microsoft. Toute utilisation de marques ou logos tiers est soumise aux politiques de ces tiers.