Dans la comparaison entre le sandbox Codex et Docker Sandboxes, la différence tient à l'endroit où s'exécutent les commandes de l'agent. Le sandbox Codex maintient les commandes sur votre propre machine et les limite avec des outils du système d'exploitation (Seatbelt sur macOS, bubblewrap et seccomp sur Linux, MXC sur Windows). Docker Sandboxes déplace l'agent dans une microVM dotée de son propre noyau, système de fichiers, Docker Engine et réseau. Choisissez le sandbox de Codex lorsque vous avez besoin de chaînes d'outils natives ; choisissez Docker Sandboxes lorsque vous voulez une frontière étanche autour de tout ce que fait l'agent.
Sandbox Codex vs Docker Sandboxes en un coup d'œil
| Sandbox Codex | Docker Sandboxes | |
|---|---|---|
| Où s'exécutent les commandes | Votre environnement existant | Une microVM par sandbox |
| Mécanisme d'isolation | Seatbelt (macOS), bubblewrap + seccomp-bpf (Linux), MXC (Windows) | Hyperviseur, noyau distinct par sandbox |
| Configuré avec | Profils de permissions dans config.toml |
CLI sbx et politiques |
| Réseau par défaut | Désactivé pour le profil :workspace |
Proxy en refus par défaut avec une liste d'autorisation par défaut |
| Outils natifs de l'hôte | Oui (Xcode, simulateurs, SDK locaux) | Non, uniquement ce qui se trouve dans la VM |
| Agents pris en charge | Codex (et toute commande via codex sandbox) |
Claude Code, Codex, Copilot, Cursor, Devin, Kiro, OpenCode et plus encore |
| Politique d'équipe | Exigences gérées via requirements.toml |
Docker AI Governance (abonnement payant séparé) |
| Prix | Inclus dans Codex | CLI sbx et calcul local gratuits ; le cloud est facturé à l'usage |
Qu'est-ce que le sandbox Codex ?
Le sandbox Codex est la couche qui limite ce que les commandes exécutées par Codex sur votre ordinateur peuvent lire, écrire et atteindre. Il ne déplace pas le travail dans un conteneur ou une VM. Il enveloppe plutôt chaque commande, et chaque processus enfant qu'elle engendre, dans les dispositifs de sandboxing du système d'exploitation lui-même, selon les règles que vous définissez dans un profil de permissions.
Le profil intégré :workspace est celui par défaut pour un dépôt Git. Il autorise les écritures dans l'espace de travail tout en gardant .git et .codex en lecture seule, autorise de larges lectures ailleurs (les compilateurs ont besoin des SDK hors du dépôt) et désactive l'accès réseau. Vous pouvez l'étendre dans config.toml. Cet exemple est tiré de l'article d'OpenAI :
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"]
".devcontainer" = "read"
".vscode" = "read"
"**/*.env" = "deny"
"secrets" = "deny"
La commande codex sandbox exécute n'importe quel programme sous un profil, en dehors d'une session d'agent. C'est ainsi que vous testez un profil, ou que vous enveloppez un serveur MCP stdio que Codex lancerait sinon sans sandbox :
codex sandbox --permission-profile dev -- bash -c 'cat > .vscode/settings.json'
Sur macOS, cette écriture échoue avec Operation not permitted. Pour des profils prêts à copier, consultez la documentation sur les profils de permissions.
Que sont les Docker Sandboxes ?
Les Docker Sandboxes exécutent des agents de codage IA dans des microVM isolées, sur votre machine ou sur l'infrastructure cloud gérée par Docker. Chaque sandbox dispose de son propre noyau, démon Docker, système de fichiers et réseau. L'agent a tous les privilèges à l'intérieur de la VM, y compris sudo et un Docker Engine privé, mais n'atteint que les ressources de l'hôte que vous partagez.
Vous le pilotez avec la CLI sbx, qui ne nécessite pas Docker Desktop. Les sandboxes locales nécessitent macOS 14 ou ultérieur sur Apple silicon, Windows 11 avec Hypervisor Platform, ou Ubuntu 24.04 ou ultérieur avec KVM. D'après le guide de démarrage :
cd ~/my-project
sbx run --name my-sandbox claude # or: sbx run codex
sbx policy ls
sbx policy allow network registry.npmjs.org
sbx stop my-sandbox
sbx rm my-sandbox
Le répertoire de votre projet est monté dans la VM au même chemin absolu. Un montage direct est en lecture-écriture, l'agent modifie donc votre arborescence de travail sur place. Avec --clone, le dépôt hôte est monté en lecture seule et l'agent travaille dans un clone Git privé à la place. Les identifiants restent sur l'hôte : la documentation d'architecture de Docker indique que « les valeurs brutes des identifiants n'entrent jamais dans la VM ».

Force de l'isolation : politique du SE vs noyau distinct
Codex contraint les processus sur le noyau de l'hôte. Sur macOS, il génère un profil Seatbelt qui part de (deny default). Sur Linux, il construit une vue du système de fichiers avec bubblewrap, dissocie les namespaces réseau, IPC et PID, et applique un filtre seccomp-bpf avec no_new_privs activé. Sur Windows, il migre vers la bibliothèque MXC (Microsoft eXecution Container) de Microsoft. Les limites sont réelles et appliquées par le noyau, mais l'agent partage votre noyau et voit votre machine à travers un filtre.
Docker place un hyperviseur entre l'agent et votre hôte. Chaque sandbox dispose d'un noyau distinct et de son propre Docker Engine « sans chemin vers le démon hôte ». Un bug du noyau ou une règle mal configurée à l'intérieur de la VM ne livre pas votre portable à l'agent.
Les deux laissent des failles qu'ils documentent honnêtement :
- Le profil par défaut de Codex maintient de larges lectures activées, si bien qu'un fichier de configuration situé ailleurs et contenant une clé API peut rester lisible. OpenAI avertit également qu'un agent pourrait altérer un fichier ignoré comme
node_modules/prettier, que votre éditeur exécuterait ensuite hors du sandbox. - Le montage direct de Docker est en lecture-écriture, si bien que les hooks Git, la configuration CI et un
Makefilemodifiés par l'agent peuvent s'exécuter plus tard sur votre hôte. Les serveurs MCP stdio locaux s'exécutent eux aussi hors de la VM du sandbox.
Aucun des deux ne dispense de relire les modifications de l'agent. Si vous luttez contre le sandbox Codex, notre guide pour contourner le sandbox Codex couvre le compromis le plus sûr.
Outils natifs et coût de mise en place
L'argument d'OpenAI contre les conteneurs est concret. Si vous mettiez Codex dans un sandbox Docker pendant le développement d'une app iOS, « Codex ne pourrait pas exécuter la chaîne d'outils de build iOS composée d'exécutables Mac natifs, ni lancer le simulateur iPhone ». Déléguer ces étapes à l'hôte les ramènerait hors du sandbox.
Le sandbox Codex ne coûte donc presque rien à mettre en place : votre shell, vos SDK et vos caches restent là où ils sont.
Les Docker Sandboxes demandent davantage au départ. La VM démarre à partir d'un template (docker/sandbox-templates:codex pour Codex), et vous ajoutez des outils via des kits ou en les installant à l'intérieur. Les sandboxes ne lisent pas la configuration au niveau utilisateur comme ~/.codex, seulement la configuration au niveau projet dans le répertoire de travail. En échange, vous obtenez un environnement propre et reproductible qui fonctionne de la même manière pour chaque agent, et une charge de travail conteneurisée peut s'exécuter en sécurité dans le Docker Engine privé de la VM.
Pour un service qui se build déjà dans un conteneur, ce coût est faible. Pour Xcode ou un SDK de bureau sous licence, il est élevé.
Contrôle réseau comparé
Les deux font passer le trafic par un proxy qui vérifie les domaines, et les deux démarrent fermés.
Codex propose trois modes : réseau désactivé (par défaut pour :workspace), accès complet (:danger-full-access), ou un proxy qui applique des règles de domaine par profil :
[permissions.dev.network]
enabled = true
[permissions.dev.network.domains]
"*.openai.com" = "allow"
"localhost" = "allow"
"evil.example" = "deny"
[features]
network_proxy = true
Les refus explicites l'emportent sur les autorisations, et une requête vers un domaine non listé peut se mettre en pause en attendant votre approbation. Le proxy ne résout un nom d'hôte qu'après son autorisation, mais OpenAI note que de larges jokers peuvent toujours permettre une exfiltration via DNS.
Docker fait passer tout le TCP sortant de la VM par un proxy sur l'hôte, bloque l'UDP et l'ICMP par défaut, et gère les règles avec sbx policy. Sa page sur le modèle de sécurité avertit que « les domaines autorisés par défaut incluent de larges jokers », alors exécutez sbx policy ls avant de faire confiance aux valeurs par défaut.
Politique d'équipe : exigences gérées vs Docker AI Governance
Les équipes ont besoin d'une politique que les utilisateurs ne peuvent pas discrètement assouplir.
Codex utilise les exigences gérées. Un administrateur déploie un requirements.toml, depuis un fichier système comme /etc/codex/requirements.toml ou depuis une politique cloud, qui limite les profils que les utilisateurs peuvent choisir :
default_permissions = ":read-only"
[allowed_permission_profiles]
":read-only" = true
":danger-full-access" = false
Docker vend cette couche sous le nom de Docker AI Governance : politiques réseau et système de fichiers des sandboxes, politiques d'outils MCP écrites en Cedar et appliquées au niveau du MCP Gateway de Docker, et journaux d'audit de chaque décision que vous pouvez conserver localement ou envoyer au cloud. La documentation de Docker liste la politique au niveau de l'organisation comme un abonnement payant séparé. L'avantage est une politique unique pour tous les agents utilisés par votre équipe, et pas seulement pour Codex.
Quand utiliser l'un ou l'autre
Il n'y a pas de gagnant unique. Faites correspondre la frontière au travail :
- Utilisez le sandbox Codex quand vous développez pour macOS ou iOS, dépendez de SDK disponibles uniquement sur l'hôte, ou voulez une configuration zéro et que Codex est votre seul agent.
- Utilisez Docker Sandboxes quand vous exécutez plusieurs agents, voulez un noyau distinct entre l'agent et votre portable, ou laissez l'agent exécuter de longues tâches sans surveillance avec Docker à l'intérieur.
- Utilisez les deux quand vous voulez Codex à l'intérieur d'une frontière étanche. La page Codex de Docker montre que
sbx run codexlancecodex --dangerously-bypass-approvals-and-sandboxpar défaut : la microVM devient le rempart et les approbations de Codex s'effacent. Gardez ce compromis en tête avant de le choisir.

Testez votre API depuis l'un ou l'autre sandbox avec Apidog CLI
Quelle que soit la frontière choisie, votre agent doit encore prouver que ses modifications fonctionnent contre une vraie API. Apidog CLI lui fournit des commandes pour les cas de test et les exécutions avec une sortie JSON qu'il peut lire. Configurez-le une fois :
npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install
Ouvrez ensuite le réseau à exactement deux hôtes : votre API et api.apidog.com, la base d'API par défaut de la CLI. Dans Codex, ajoutez les deux à la table [permissions.<name>.network.domains] du profil. Dans Docker Sandboxes, exécutez sbx policy allow network api.apidog.com ainsi que l'hôte de votre API.
Donnez un seul prompt à votre agent :
Using Apidog CLI, create a test case in project <projectId> for
POST /orders on endpoint <endpointId> that asserts a 201 status and an
"id" field in the body. Run it against environment <envId> and summarize
any failures.
L'agent lit le schéma, valide sa charge utile et exécute le cas :
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog test-case run --project <projectId> --endpoint <endpointId> -e <envId> -r cli,json
Si une exécution échoue avec une erreur réseau, le sandbox a fait son travail : vérifiez quel hôte manque dans la liste d'autorisation. Pour le tutoriel complet sur Codex, consultez Apidog CLI dans Codex, et remplacez -r cli,json par -r junit lorsque la même exécution passe dans un pipeline CI. Le plan gratuit d'Apidog couvre jusqu'à 4 utilisateurs.
FAQ
Le sandbox Codex est-il un conteneur ? Non. Codex contraint les commandes dans votre environnement existant avec Seatbelt sur macOS, bubblewrap et seccomp-bpf sur Linux, et MXC sur Windows. Il n'y a ni image de système de fichiers séparée ni VM.
Les Docker Sandboxes ne sont-elles que des conteneurs ? Non. La documentation de Docker les décrit comme des microVM avec isolation par hyperviseur et un noyau distinct par sandbox. Chacune exécute son propre Docker Engine, ce qui permet à l'agent de builder et d'exécuter des conteneurs à l'intérieur.
Puis-je exécuter Codex à l'intérieur de Docker Sandboxes ? Oui. sbx run codex lance Codex dans une microVM. Par défaut, il démarre avec --dangerously-bypass-approvals-and-sandbox, la VM, et non le sandbox de Codex, constituant la frontière.
Les Docker Sandboxes sont-elles gratuites ? Docker indique que la CLI sbx et le calcul local des sandboxes sont gratuits, y compris pour un usage commercial. Les sandboxes cloud utilisent un abonnement à l'usage, les frais du fournisseur de modèle sont séparés, et la gestion des politiques au niveau de l'organisation est un abonnement payant distinct.
L'un ou l'autre sandbox couvre-t-il les serveurs MCP ? Pas par défaut. Codex ne sandboxe pas les serveurs MCP stdio sauf si vous les enveloppez avec codex sandbox. Docker exécute les serveurs MCP stdio locaux hors de la VM ; son gateway MCP et ses politiques Cedar régissent les serveurs qui y passent.
