Gouvernance des agents IA : un bac à sable ne remplace pas la validation

Besoin d’une gouvernance des agents IA pour les agents de codage que votre équipe utilise ? Découvrez comment Codex et les sandboxes Docker définissent des limites, et qui est responsable de chaque exécution et en assure la revue.

Ryan Mitchell

Ryan Mitchell

20 novembre 2026

Gouvernance des agents IA : un bac à sable ne remplace pas la validation

En bref : la gouvernance des agents IA désigne l'ensemble des règles qui déterminent qui peut lancer un agent, à quoi il peut toucher, à quoi il peut accéder, qui approuve lorsqu'il demande davantage de droits, et quelle trace il laisse. Le sandbox Codex d'OpenAI et AI Governance de Docker couvrent tous deux la moitié « exécution » de cette liste. L'autre moitié — la propriété et la revue — relève de la façon dont votre équipe attribue et valide le travail des agents.

Qu'est-ce que la gouvernance des agents IA ?

La gouvernance des agents IA, c'est l'ensemble des politiques et de la traçabilité qui encadrent les agents autonomes : quelles personnes peuvent les lancer, quels fichiers et destinations réseau ils peuvent utiliser, quels outils ils peuvent appeler, quand un humain doit approuver une action, et comment chaque décision est consignée. Elle considère l'agent comme un acteur doté d'autorité, et non comme un processus à contenir.

Cette façon de voir les choses a fait la une du secteur cette semaine. Le 19 novembre, Docker a refondu sa marque autour d'une phrase de sa directrice marketing Terri Avnaim : « Les conteneurs isolent les charges de travail. Mais les agents ne sont pas des charges de travail. Les agents sont des acteurs. » L'article poursuit : « Les agents décident eux-mêmes de ce qu'ils exécutent, de ce à quoi ils accèdent et de ce qu'ils modifient. »

La veille, OpenAI publiait Inside the Codex sandbox, un compte rendu détaillé de la manière dont Codex limite ce que les commandes peuvent faire sur votre ordinateur. Deux éditeurs, deux conceptions, une même question. Si votre équipe exécute déjà des agents de codage via Sharkly, ce guide montre où s'arrêtent ces contrôles d'exécution et où la gouvernance d'équipe doit prendre le relais.

Pourquoi « les agents sont des acteurs » change la donne

Un conteneur répond à une seule question : que peut voir ce processus ? Cette question reste essentielle. Mais elle ne couvre pas tout ce que fait un agent.

Un agent lit une tâche, choisit des commandes, décide quels fichiers modifier, décide d'appeler ou non un outil, et demande parfois plus d'accès en cours de route. Chacun de ces gestes est une décision. L'article de Docker sur AI Governance résume bien le fossé : « Une décision de modèle n'est pas automatiquement une action autorisée. »

La gouvernance passe donc de « isoler le processus » à « autoriser l'acteur ». Cinq questions appellent une réponse :

  1. Qui peut le lancer ? Quelles personnes peuvent attribuer ou déclencher un agent donné.
  2. À quoi peut-il toucher ? Les chemins du système de fichiers, en lecture ou en écriture.
  3. À quoi peut-il accéder ? Les domaines réseau et les outils MCP (Model Context Protocol).
  4. Qui approuve les escalades ? Ce qui se passe lorsque l'agent demande plus que ses droits par défaut.
  5. Qu'est-ce qui est consigné ? Qui a exécuté quoi, ce qui a été autorisé ou refusé, et qui a validé le résultat.

Les deux approches actuelles traitent les questions 2 à 4 de manières différentes. La question 1 et l'essentiel de la question 5 restent hors de leur périmètre.

Les cinq couches de la gouvernance des agents IA : qui lance l'agent, les limites du système de fichiers, les limites réseau et des outils MCP, l'approbation des escalades et la trace d'audit

Comment le sandbox Codex encadre l'accès des agents

Le sandbox Codex contraint les commandes à l'intérieur de votre environnement existant au lieu de les déplacer dans une VM ou un conteneur. La raison invoquée par OpenAI est pragmatique : une compilation iOS a besoin des outils Mac natifs et du simulateur, que le conteneur Docker ne peut pas exécuter.

L'application des règles repose sur chaque système d'exploitation. Codex utilise Seatbelt sur macOS, bubblewrap et seccomp-bpf sur Linux, et migre Windows vers la bibliothèque MXC (Microsoft eXecution Container) de Microsoft. Les processus enfants héritent du sandbox, si bien que les limites couvrent toute l'arborescence des processus.

Que contrôlent les profils d'autorisation de Codex ?

Un profil d'autorisation définit les règles de fichiers et de réseau d'une session. Le profil intégré :workspace autorise l'écriture dans l'espace de travail, conserve .git et .codex en lecture seule, autorise des lectures étendues et désactive l'accès réseau. Vous pouvez l'étendre :

default_permissions = "dev"

[permissions.dev]
description = "Development with extra read-only protections."
extends = ":workspace"

[permissions.dev.filesystem]
"~/build-cache" = "write"

[permissions.dev.filesystem.":workspace_roots"]
".vscode" = "read"
"**/*.env" = "deny"
"secrets" = "deny"

Les règles réseau passent par un proxy qui vérifie chaque requête au regard de listes d'autorisation et de refus. Les règles de refus l'emportent. Une requête vers un domaine non listé est mise en attente pendant que Codex interroge l'utilisateur ou la redirige vers la revue automatique. La référence complète des clés se trouve dans la documentation des autorisations Codex.

Comment les administrateurs imposent-ils les limites ?

Le contrôle d'équipe passe par les exigences gérées de requirements.toml, qui peuvent provenir de fichiers système ou d'une politique cloud. L'exemple d'OpenAI verrouille chaque utilisateur en lecture seule :

default_permissions = ":read-only"

[allowed_permission_profiles]
":read-only" = true
":danger-full-access" = false

L'escalade est explicite. Une commande peut demander with_additional_permissions (davantage d'accès à l'intérieur du sandbox) ou require_escalated (s'exécuter en dehors), avec une justification visible par l'utilisateur. C'est le harnais qui décide, pas le modèle.

Deux détails comptent pour la gouvernance. D'une part, codex sandbox --permission-profile dev -- <command> permet de tester un profil avant de lui faire confiance. D'autre part, Codex ne sandboxe pas la commande qui démarre un serveur MCP stdio, car il ne peut pas deviner de quoi ce serveur a besoin. C'est à vous de l'encapsuler.

Comment fonctionnent Docker Sandboxes et AI Governance

Docker a choisi la voie inverse. Les Docker Sandboxes offrent à chaque agent une microVM isolée dotée de son propre Docker Engine, de son propre système de fichiers et de son propre réseau, le tout géré via la CLI sbx.

AI Governance ajoute par-dessus une politique d'organisation, en trois volets :

  • Politiques de sandbox : autoriser ou bloquer des domaines, des plages d'adresses IP et des ports, et contrôler les chemins de l'hôte qui peuvent être montés, en lecture seule ou en lecture-écriture. La documentation sur la gouvernance d'organisation précise que la politique est en refus par défaut.
  • Gouvernance des outils MCP : des politiques pour le trafic MCP traversant la passerelle MCP de Docker, écrites en Cedar, qui définissent quels serveurs peuvent être enregistrés et quels appels d'outils, ressources et prompts sont autorisés. Les politiques peuvent aussi exiger une confirmation pour certains appels.
  • Audit et visibilité : des enregistrements structurés de chaque décision de politique, avec le principal, l'action, la cible, la décision et l'horodatage, exportables ou transmis à un SIEM.

Un développeur peut vérifier une frontière avant de commencer à travailler :

$ sbx policy check network api.anthropic.com
Allowed: api.anthropic.com
$ sbx policy check network blocked.example.com
Denied: blocked.example.com

Docker reconnaît une limite : les politiques MCP ne s'appliquent qu'au trafic passant par sa passerelle. Une connexion directe à un serveur MCP distant relève en revanche de la politique réseau du sandbox. Docker commercialise AI Governance comme une offre distincte, via son équipe commerciale.

Sandbox Codex vs AI Governance de Docker

Question Sandbox Codex Docker Sandboxes + AI Governance
Où s'exécute l'agent Votre environnement existant, sandbox au niveau de l'OS MicroVM isolée par agent
Règles de fichiers Profils d'autorisation : read, write, deny par chemin Politiques de montage, lecture seule ou lecture-écriture
Règles réseau Proxy avec listes d'autorisation/refus de domaines, requêtes non listées mises en attente d'approbation Politiques de domaines, de plages d'IP et de ports, refus par défaut
Outils MCP Serveurs stdio non sandboxés, sauf si vous les encapsulez dans codex sandbox Politiques Cedar au niveau de la passerelle MCP
Application par l'administrateur requirements.toml, système ou cloud Docker Home ou l'API AI Governance
Escalade Demande par commande, décision de l'utilisateur ou revue automatique Règles de confirmation sur des appels d'outils spécifiques
Audit N'est pas le sujet de l'article Enregistrements structurés des décisions de politique

Privilégiez le sandbox Codex lorsque vos agents ont besoin des outils natifs de la machine hôte et que vous travaillez principalement avec Codex. Privilégiez l'approche de Docker lorsque vous voulez une frontière d'isolation unique pour de nombreux agents et une piste d'audit centralisée. Beaucoup d'équipes combineront les deux.

Là où s'arrêtent les contrôles d'exécution

Les deux systèmes répondent à la question « que peut faire ce processus, là, maintenant ? ». Aucun ne répond à « pourquoi cet agent tourne-t-il, qui l'a demandé et qui a validé le résultat ? »

Le fossé apparaît vite. Un sandbox peut bloquer une écriture dans .vscode, mais il ne peut pas vous dire qu'un agent a été lancé depuis l'ordinateur de quelqu'un à 2 heures du matin sans ticket. Un journal d'audit peut montrer un appel MCP autorisé, mais pas si une personne a relu le diff avant la fusion. L'enregistrement contient des actions, mais ni intention, ni validation.

Nous avons traité le volet propre à chaque agent dans les autorisations des agents de codage et le volet fusion dans les points de validation pour les agents de codage. La gouvernance à l'échelle de l'équipe relie les deux.

Comment Sharkly attribue à chaque exécution d'agent un propriétaire, une tâche et une étape de revue

Sharkly ne remplace ni le sandbox Codex ni les Docker Sandboxes. Il se place au-dessus des agents de codage et ajoute l'enregistrement du travail qui manque aux contrôles d'exécution. Voici la correspondance avec les cinq questions :

Qui peut le lancer. Chaque Agent possède une visibilité Personnel ou Espace, et cette visibilité détermine qui peut l'attribuer, discuter avec lui ou le déclencher depuis un commentaire de tâche. Un espace privé ne rend ses tâches visibles qu'aux membres de l'espace.

Où il s'exécute. Un ordinateur a un propriétaire et sa propre visibilité. Seul le propriétaire peut le supprimer ou modifier les organisations autorisées à utiliser un ordinateur personnel ; un administrateur d'organisation ne peut pas passer outre. Le propriétaire peut détacher un Agent, ce qui annule ses exécutions en cours.

Ce à quoi il a accès. Une exécution adossée à une tâche embarque la tâche, les commentaires récents, les instructions de l'Agent, les compétences, les dépôts, et uniquement les variables d'environnement et les liaisons de secrets configurées pour elle. Chaque tâche dispose d'un répertoire isolé, et le travail sur un dépôt peut utiliser un worktree distinct par exécution.

Qui approuve. Le workflow du type de tâche limite les statuts qu'un Agent peut définir. Un Agent peut laisser une tâche en attente de revue humaine, laquelle arrive dans la boîte de réception de la personne responsable.

Ce qui est consigné. Le journal d'exécution affiche la source du déclenchement, les heures de début et de fin, les appels d'outils, les événements du Runtime et les détails d'échec. Les messages de l'Agent destinés à l'équipe deviennent des commentaires liés à l'exécution.

Une tâche Sharkly comme registre de gouvernance : un propriétaire attribue la tâche, l'agent s'exécute dans un ordinateur sandboxé et un humain relit le résultat avant de passer à la suite

Ainsi, le sandbox décide ce qu'une commande peut faire, et la tâche décide pourquoi elle a tourné et qui a validé. La documentation Sharkly détaille la visibilité, les ordinateurs et les états d'exécution.

Une checklist de gouvernance applicable dès cette semaine

  1. Listez tous les agents utilisés par votre équipe et désignez un responsable humain pour chacun.
  2. Rédigez un profil d'autorisation ou une politique de sandbox par rôle, en partant du principe de lecture seule.
  3. Testez chaque profil avec codex sandbox ou sbx policy check avant le déploiement.
  4. Encapsulez ou faites passer par une passerelle chaque serveur MCP ; ne laissez pas de serveurs stdio sans sandbox.
  5. Verrouillez les profils de façon centralisée avec requirements.toml ou une politique d'organisation.
  6. Exigez une tâche pour chaque exécution d'agent, afin que chaque exécution ait une raison d'être et un responsable.
  7. Faites passer les résultats par un statut de revue humaine avant la fusion.
  8. Tenez les secrets à l'écart du texte des tâches, des instructions et des compétences ; liez-les au moment de l'exécution.

Notre checklist de garde-fous sur les secrets approfondit l'étape 8.

Conclusion

Les agents sont des acteurs : les gouverner ne se limite donc pas à isoler un processus. Le sandbox Codex et AI Governance de Docker apportent désormais des réponses solides sur les limites de fichiers, de réseau et d'outils. Il reste à donner un cadre à la propriété, à l'intention et à la revue. Choisissez un sandbox, rédigez votre premier profil, puis connectez vos agents à Sharkly pour que chaque exécution parte d'une tâche et se termine par la validation d'une personne.

FAQ

Quelle différence y a-t-il entre gouvernance des agents IA et sécurité des agents IA ?

La sécurité est la couche d'application des règles : sandboxes, politiques réseau, restrictions d'outils. La gouvernance englobe cette couche ainsi que les décisions qui l'entourent : qui peut exécuter tel agent, qui approuve les escalades et qui valide le résultat.

Le sandbox Codex fonctionne-t-il sans Docker ?

Oui. Codex s'appuie sur le sandbox propre à chaque système d'exploitation (Seatbelt, bubblewrap avec seccomp, ou MXC) et exécute les commandes dans votre environnement existant, et non dans un conteneur.

Peut-on sandboxer un serveur MCP dans Codex ?

Oui, mais pas par défaut. Codex ne sandboxe pas la commande qui démarre un serveur MCP stdio. Il faut l'encapsuler avec codex sandbox --permission-profile <name> -- dans les champs command et args du serveur.

Que consigne AI Governance de Docker ?

Il enregistre les décisions de politique du sandbox et les événements de session avec le principal, l'action, la cible, la décision et l'horodatage. Docker précise que ces enregistrements contiennent des métadonnées de gouvernance, et non le contenu des prompts ou des réponses.

Faut-il à la fois un sandbox et un tableau de tâches ?

Ils répondent à des questions différentes. Un sandbox limite ce qu'une commande peut faire. Une tâche consigne pourquoi l'exécution a eu lieu, qui en est responsable et qui a relu le résultat. Les équipes qui utilisent plusieurs agents ont généralement besoin des deux.

Un agent peut-il approuver sa propre escalade ?

Dans aucune des deux conceptions. Avec Codex, c'est le harnais qui décide, en interrogeant l'utilisateur ou en passant par la revue automatique. Avec Docker, ce sont les règles de confirmation et la politique de refus par défaut qui décident, pas l'agent.

À explorer aussi

Alternative open source à Slack : comment ExitPath vous aide à quitter Slack

Alternative open source à Slack : comment ExitPath vous aide à quitter Slack

Vous cherchez une alternative open source à Slack ? Découvrez ce qu’ExitPath recommande de migrer vers Mattermost, Zulip ou Element, et évitez de perdre le travail de vos agents.

20 novembre 2026

GPT-6.2 Astra vs Fable 5.2 : testez les deux sur votre propre dépôt

GPT-6.2 Astra vs Fable 5.2 : testez les deux sur votre propre dépôt

GPT-6.2 Astra vs Fable 5.2 : lequel devrait faire tourner vos agents de codage ? Voyez où les tokens à prix égal font pencher la facture, et testez les deux sur votre propre dépôt.

20 novembre 2026

Tarifs de GPT-6.2 : combien coûtent Astra et Sol pour les équipes d'agents IA

Tarifs de GPT-6.2 : combien coûtent Astra et Sol pour les équipes d'agents IA

Vous vous demandez ce que la tarification de GPT-6.2 implique pour votre équipe d'agents ? Découvrez le coût par tâche d'Astra et Sol, ainsi que les plafonds qui vous aident à maîtriser vos dépenses.

20 novembre 2026