Prime Radiant : des sandboxes externes pour les agents de programmation
Simon Willison et Prime Radiant ont publié le 17 novembre 2026 trois implémentations expérimentales de sandbox, séparant les agents de programmation des environnements qui exécutent leurs commandes. Les sandboxes externes pour agents de programmation placent le code généré dans un environnement Linux isolé tout en maintenant l’agent à l’extérieur. Cette séparation offre un contrôle de sécurité concret, mais sa portée dépend des outils qui franchissent réellement cette frontière.
Cette publication s’adresse aux développeurs qui expérimentent avec des modèles locaux, où des erreurs et des instructions malveillantes peuvent transformer des tâches de programmation ordinaires en actions dommageables. L’injection de prompt, une attaque qui oriente un agent à travers du contenu non fiable, fait partie des motivations. La tension centrale consiste à fournir à un agent assez d’accès pour accomplir son travail tout en limitant les dommages que cet accès peut causer.
Claude Code, Codex et Pi offrent le point de comparaison immédiat. Chacun se connecte différemment, de sorte que partager un environnement d’exécution ne signifie pas bénéficier d’une protection identique. Pour les développeurs et les équipes d’ingénierie, l’annonce soulève une question pratique : quelles capacités restent sur l’hôte une fois l’exécution des commandes déplacée ailleurs ?
Les sandboxes externes pour agents de programmation proposent trois implémentations
Willison présente le projet comme une expérimentation d’exécution plus sûre, développée avec Prime Radiant, le laboratoire de recherche à l’origine de Superpowers. Son annonce des sandboxes externes identifie trois implémentations qui exposent une interface locale commune.
Une sandbox est un environnement d’exécution restreint qui limite les ressources auxquelles le code exécuté peut accéder. Dans ce modèle, l’agent envoie le travail vers cet environnement plutôt que d’exécuter directement les commandes sur sa propre machine. L’agent continue de gérer la conversation et de décider des actions à entreprendre.
La publication rend la frontière d’exécution interchangeable tout en maintenant l’agent à l’extérieur de cette frontière.
Une interface de programmation d’application, ou API, définit la manière dont les composants logiciels échangent requêtes et résultats. Ici, une API localhost, accessible depuis le même ordinateur, relie l’agent au serveur de sandbox. Cette interface sépare l’intégration de l’agent de la technologie qui exécute le code.
Cette distinction importe, car un environnement d’exécution et un agent remplissent des fonctions différentes. L’environnement contrôle l’accès aux ressources. L’agent interprète une tâche, choisit des outils et répond aux résultats. Combiner ces responsabilités peut rendre plus difficile l’identification du point où une restriction s’applique réellement.
Les séparer crée une question plus explicite pour quiconque évalue le système : quelle requête quitte l’agent, et quelle autorité la reçoit ? Cette question est plus utile que de considérer une session entière de programmation comme une activité unique et fiable.
Prenons une tâche de maintenance hypothétique concernant un dépôt peu familier. L’agent doit inspecter des fichiers, exécuter des tests et proposer des modifications. L’exécution de ces commandes dans un environnement restreint peut réduire leur portée au-delà du projet attribué. Elle n’établit pas que les modifications proposées sont correctes.
La même distinction s’applique lorsqu’une dépendance exécute un script d’installation. La frontière pertinente concerne les autorisations disponibles pour ce script. La question de savoir si le modèle avait l’intention du comportement résultant est distincte. Une commande accidentelle et une commande malveillante peuvent exercer la même capacité accordée.
C’est pourquoi cette annonce mérite l’attention au-delà de ses exemples d’installation. Elle présente une architecture que les développeurs peuvent inspecter et comparer. Elle ne nécessite pas d’accepter le jugement du modèle comme mécanisme chargé d’appliquer chaque restriction.
Le changement immédiat est donc précis. Prime Radiant a publié des prototypes compatibles permettant d’acheminer l’exécution vers des environnements distincts. L’implication plus large est analytique : le choix du modèle et la politique d’exécution peuvent être évalués comme des décisions liées, mais distinctes.
Cette séparation clarifie également les responsabilités. Un modèle peut recommander une action, une intégration peut l’acheminer, et un environnement d’exécution peut la restreindre. L’évaluation du flux de travail complet exige d’examiner chaque transfert plutôt que de supposer que la restriction finale couvre tout ce qui la précède.
Une interface commune ne rend pas les backends équivalents
Les trois implémentations reposent sur des fondations différentes. Leur interface commune rend la comparaison possible, mais elle n’établit pas une performance, une compatibilité ou une sécurité équivalentes.
L’implémentation de sandbox v86 utilise un serveur Node.js et v86, un émulateur x86 compilé en WebAssembly, pour exécuter Alpine Linux. WebAssembly est un format exécutable portable utilisé ici comme élément de la pile d’émulation. Le dépôt décrit un environnement invité minimal, avec des outils supplémentaires disponibles via la configuration de démarrage.
L’implémentation Apple Containers utilise un serveur Python autour des outils de conteneurs d’Apple. Sa documentation décrit des modifications d’environnement jetables, ainsi que des écritures persistantes dans des dossiers hôtes montés. Elle distingue aussi explicitement son comportement de système de fichiers de celui de l’implémentation v86.
L’implémentation de sandbox Quicksand utilise la bibliothèque Quicksand de Microsoft avec QEMU, un logiciel qui exécute des machines virtuelles. Une machine virtuelle fournit un système d’exploitation invité séparé de l’hôte grâce à une couche de virtualisation ou d’émulation. Cette implémentation documente également ses propres mécanismes de montage et de mise en réseau.
La compatibilité au niveau de l’interface n’implique pas une équivalence sous-jacente.
Pour une équipe d’ingénierie, la conséquence utile est la liberté d’évaluer la technologie d’exécution sans repenser l’ensemble du flux de travail de l’agent. Cela réduit le couplage conceptuel entre un assistant de programmation et son environnement d’exécution.
Toutefois, le choix entre ces implémentations exige toujours une charge de travail représentative. Une petite tâche de script et une compilation d’application riche en dépendances sollicitent différentes parties d’un environnement. Une démonstration réussie de la première ne peut pas établir l’adéquation de la seconde.
La disponibilité des paquets constitue une autre distinction pratique. Un environnement d’exécution côté hôte n’existe pas automatiquement dans l’environnement invité. Les développeurs qui évaluent un flux de travail isolé doivent distinguer le logiciel qui sert les requêtes du logiciel disponible pour les exécuter.
Dans le cas contraire, cela peut produire des échecs déroutants. Une commande qui fonctionne sur la machine d’un développeur peut échouer dans un environnement restreint parce qu’un environnement d’exécution manque. Cet échec dit peu de chose sur le raisonnement de l’agent et rien de définitif sur la frontière d’isolation.
La même prudence s’applique à la vitesse. L’annonce n’établit pas de classement des performances contrôlé entre les implémentations. Une comparaison responsable maintiendrait constants la tâche, l’état des dépendances, le matériel et la méthode de mesure.
La commodité opérationnelle mérite également un traitement distinct. Un backend qui s’intègre à une configuration de développement existante peut être plus facile à évaluer. Cette commodité ne rend pas automatiquement ses restrictions plus fortes. À l’inverse, une configuration plus complexe ne constitue pas une preuve de meilleure protection.
L’interface commune de la publication est précieuse précisément parce que ces questions demeurent distinctes. Les développeurs peuvent se demander si l’intégration de l’agent fonctionne, si l’application se compile et si les restrictions prévues sont respectées.
Il s’agit de critères d’acceptation différents. Les regrouper dans une seule session de terminal réussie masquerait les différences les plus importantes entre les backends.
Pour les acheteurs, cela modifie également les éléments de preuve à demander. Une technologie d’isolation reconnue constitue un point de départ. Les éléments utiles concernent la façon dont une implémentation particulière expose les fichiers, contrôle le trafic, gère les défaillances et interagit avec l’agent sélectionné.
Claude Code met en évidence la différence entre commandes et outils
La réserve la plus importante apparaît dans les détails d’intégration des agents de Prime Radiant. Claude Code achemine les commandes Bash vers la sandbox, tandis que ses outils natifs Read et Edit restent sur l’hôte.
Bash est un interpréteur de commandes qui exécute des scripts et des commandes de terminal. Rediriger Bash modifie l’endroit où ces commandes s’exécutent. Cela ne redirige pas automatiquement toutes les autres capacités offertes par l’agent.
L’annonce décrit un acheminement plus large pour les autres intégrations. Codex envoie les opérations de processus et de système de fichiers, y compris son opération native de patch. Pi remplace ses outils d’exécution et de gestion de fichiers listés, les outils intégrés étant désactivés dans la configuration documentée.
Prime Radiant présente également ces implémentations comme des prototypes expérimentaux n’ayant pas reçu un audit suffisant pour les charges de travail sensibles. Ces réserves doivent accompagner les fonctionnalités, plutôt que d’être enfouies sous une affirmation générale de sécurité.
La question de sécurité est de savoir quels outils franchissent la frontière, et non simplement si le flux de travail inclut une sandbox.
Cette distinction met les développeurs qui créent des intégrations d’agents face à leurs responsabilités. Un wrapper shell peut être utile tout en ne couvrant qu’une partie des capacités de l’agent. L’intégration doit rendre cette portée compréhensible pour la personne qui attribue le travail.
Imaginons une tâche hypothétique demandant à un agent d’inspecter un dépôt et de mettre à jour un fichier de configuration. L’agent peut inspecter les fichiers avec un lecteur natif, exécuter les tests via Bash et effectuer les modifications avec un outil distinct. Ces actions peuvent emprunter des chemins différents.
Une réponse Linux issue d’une commande de terminal établit l’endroit où cette commande s’est exécutée. Elle n’établit pas où se sont déroulées la lecture précédente ou la modification suivante. La considérer comme preuve d’un confinement complet reviendrait à confondre un résultat visible avec la portée de l’application des restrictions.
Pour Claude Code, la distinction documentée est particulièrement concrète. Les restrictions sur les dossiers montés dans la sandbox ne deviennent pas des restrictions sur les opérations natives Read et Edit côté hôte. Des autorisations supplémentaires sur l’hôte restent donc pertinentes.
Cela ne rend pas l’intégration shell inutile. Les outils de compilation, les scripts et les sous-processus peuvent toujours représenter une surface d’exécution significative. La limite importante est que réduire la portée de cette surface ne décrit pas l’autorité de tous les outils restants.
C’est aussi pourquoi les comparaisons entre Claude Code, Codex et Pi doivent éviter une simple étiquette « protégé ou non protégé ». Le chemin d’intégration compte autant que le backend sélectionné. Les utilisateurs doivent comprendre les deux avant d’interpréter une tâche réussie.
Pour les équipes d’entreprise, l’implication est organisationnelle. Le développeur qui configure un serveur d’exécution ne contrôle pas forcément toutes les extensions ou connexions disponibles pour un agent. Une évaluation complète exige un inventaire des capacités, y compris celles qui restent hors du service d’exécution.
Cet inventaire peut être plus révélateur qu’une description générale du produit. Il indique où l’application des restrictions existe et où une autre politique doit assumer la responsabilité.
La publication remet ainsi en cause un langage imprécis autour de l’isolation des agents. Une description précise identifie les opérations acheminées, les capacités hôtes restantes et le comportement attendu lorsque l’environnement externe devient indisponible.
L’accès aux fichiers et au réseau détermine la portée restante
Les sandboxes externes pour les agents de programmation placent les autorisations de ressources au cœur de leur conception. Le compromis essentiel est simple : un travail utile exige des accès, et chaque capacité accordée crée un chemin prévu à travers la frontière.
Le protocole de sandbox partagé définit des comportements observables pour l’exécution, les opérations sur le système de fichiers et les fonctionnalités facultatives. Il évite explicitement de promettre des performances backend ou une sémantique de montage identiques.
Un montage rend un répertoire hôte sélectionné disponible dans l’environnement invité. L’accès en lecture seule permet l’inspection ; l’accès en lecture-écriture autorise également les modifications. Le protocole considère l’accès aux fichiers hôtes montés comme une exposition délibérée, non comme une évasion.
Une frontière d’isolation fonctionnelle peut tout de même permettre d’endommager des ressources intentionnellement placées à sa portée.
Prenons un dépôt hypothétique monté pour être modifié. Un agent a besoin d’un accès en écriture pour changer les fichiers source. S’il supprime ces fichiers par une opération autorisée, le résultat peut être destructeur, même si la frontière s’est comportée conformément à sa configuration.
La conséquence analytique est importante : le confinement et la préservation sont deux objectifs distincts. Le confinement concerne ce qu’une opération peut atteindre. La préservation concerne la possibilité de récupérer un état précieux après qu’une opération autorisée a mal tourné.
Un espace de travail restreint avec droit d’écriture peut mieux servir à la fois le développement et la revue qu’un accès étendu à des dossiers sans rapport. Il ne s’agit pas d’affirmer que chaque projet nécessite la même configuration. L’idée est que la tâche assignée doit justifier chaque autorisation d’accès.
Les éléments sensibles du projet méritent le même examen. Une frontière de répertoires ne distingue pas les fichiers contenant des fixtures ordinaires de ceux qui renferment des informations confidentielles. Si l’environnement peut lire les deux, l’opérateur a exposé les deux.
Les autorisations réseau introduisent un compromis similaire. Un proxy est un intermédiaire qui reçoit et transmet des requêtes réseau. Une liste d’autorisation définit les destinations ou opérations permises via cet intermédiaire.
L’avantage architectural est la médiation : l’accès réseau devient un élément qu’un composant externe peut évaluer. La limite est sémantique. L’autorisation de contacter une destination ne garantit pas que chaque requête permise sert la tâche voulue par l’utilisateur.
Par exemple, un flux de travail hypothétique peut devoir récupérer des métadonnées de dépendances. Cette exigence ne justifie pas intrinsèquement des opérations d’écriture sans rapport vers un autre service. Définir précisément l’action nécessaire facilite l’évaluation de l’autorisation.
Les méthodes HTTP, qui identifient les actions des requêtes, offrent un moyen de distinguer les opérations. Les chemins peuvent davantage restreindre la ressource demandée. Même dans ce cas, les évaluateurs doivent comprendre le service qui reçoit la requête plutôt que de se fier uniquement aux libellés.
Le remplacement d’identifiants ajoute une autre distinction. Un identifiant est un secret utilisé pour authentifier un accès. Garder sa valeur hors du code généré peut réduire l’exposition directe, mais l’opération authentifiée conserve son autorité.
Un agent incapable d’afficher un secret peut néanmoins demander une action autorisée par ce secret. La confidentialité des secrets et le contrôle des autorisations répondent donc à des questions différentes. N’évaluer que la première laisse la seconde sans réponse.
C’est le compromis central de l’annonce. Les développeurs bénéficient de contrôles explicites sur les ressources d’exécution, mais ces contrôles imposent des décisions sur le travail autorisé. L’isolation n’élimine pas ces décisions ; elle rend leurs conséquences plus faciles à identifier.
Les prototypes nécessitent des preuves au-delà de démonstrations réussies
L’interprétation sceptique la plus solide ne suppose pas que la conception est inefficace. Elle exige que les preuves disponibles restent dans leur véritable périmètre.
Une démonstration peut établir qu’une commande précise s’est exécutée dans un environnement particulier. Un test de compatibilité peut établir qu’un client a échangé les messages attendus. Aucun de ces résultats ne prouve, à lui seul, une résistance à une tentative hostile de franchir la frontière.
La correction fonctionnelle, l’application des politiques et l’assurance de sécurité exigent des preuves différentes.
Le protocole publié est utile, car il décrit le comportement attendu dans des termes testables. Toutefois, la conformité à une interface ne certifie pas chaque propriété de l’implémentation sous-jacente.
Cela compte lorsque l’on compare les backends. Une réponse identique à une opération de fichier ordinaire peut masquer des mécanismes d’application différents. Ces différences méritent attention lors de l’évaluation de structures de fichiers inhabituelles, de modifications concurrentes ou d’entrées hostiles.
La question pertinente n’est pas de savoir si tous les détails d’implémentation doivent figurer dans une annonce de lancement. Elle est de savoir si une équipe comprend quelles affirmations l’annonce établit et lesquelles exigent une validation supplémentaire.
Pour les charges de travail sensibles, un modèle de menace documenté serait particulièrement utile. Un modèle de menace décrit les capacités de l’attaquant et les ressources protégées autour desquelles un système est conçu. Sans cela, différents lecteurs peuvent interpréter la même affirmation selon des hypothèses différentes.
Un lecteur peut s’inquiéter d’une suppression accidentelle durant une tâche de programmation. Un autre peut s’inquiéter du contenu malveillant d’un dépôt. Un troisième peut supposer une protection contre un logiciel hostile déjà exécuté sur l’hôte.
Il s’agit de scénarios matériellement différents. Une conception peut traiter une partie de l’un sans traiter tous les autres. Un périmètre clair empêche qu’un contrôle utile devienne une promesse non étayée.
L’exposition côté hôte reste un autre domaine d’évaluation. Comme l’agent vit hors de l’environnement d’exécution, les autorisations qui l’entourent restent importantes. Déplacer du code généré ailleurs ne déplace pas, à lui seul, la conversation, la connexion au modèle ou les outils hôtes sans rapport.
Les organisations doivent également distinguer la réussite d’une tâche d’un comportement acceptable. Un agent peut effectuer la modification demandée tout en sollicitant des autorisations inutiles au passage. À l’inverse, une requête bloquée peut représenter une application réussie de la politique, même si la tâche s’arrête.
Cela crée un défi de mesure. Les mesures de productivité récompensent l’achèvement, tandis que les contrôles d’isolation doivent parfois interrompre cet achèvement. Évaluer les deux impose d’enregistrer pourquoi une action a échoué et si cet échec correspondait à la politique prévue.
La documentation et les procédures de récupération comptent pour la même raison. Une opération refusée ne doit pas automatiquement devenir une invitation à élargir les accès. L’opérateur a besoin d’un contexte suffisant pour déterminer si la tâche exige réellement cette autorisation.
Les équipes peuvent conserver leurs notes d’évaluation avec des documents techniques locaux. Enregistrer l’agent, le backend, les ressources accordées et le résultat observé rend les comparaisons ultérieures plus pertinentes.
Rien de cela n’établit l’existence d’une faille spécifique dans les prototypes. Cela identifie les preuves nécessaires avant d’élargir leur rôle. La publication permet l’expérimentation ; une confiance plus large exige des résultats liés à une charge de travail et un modèle de menace clairement définis.
Qu’est-ce qui rendrait les sandboxes externes prêtes pour un usage plus large ?
La prochaine période d’évaluation devrait se concentrer sur les preuves plutôt que sur une collection plus vaste de démonstrations. Trois signaux renforceraient ou affaibliraient l’argument en faveur de cette architecture dans le développement pratique.
Les signaux décisifs sont des tests indépendants de la frontière, un routage complet des outils et des politiques d’autorisation utilisables.
Premièrement, surveillez les analyses de sécurité indépendantes des implémentations. Une évaluation utile identifierait les ressources protégées, les capacités des attaquants, les versions testées, les constats et les correctifs. Une approbation générale fournirait moins d’informations qu’une revue technique au périmètre étroit.
Des constats publiés ne discréditeraient pas automatiquement l’architecture. Ils rendraient ses limites plus concrètes. La distinction importante porterait sur les problèmes résolus par des changements d’implémentation et les hypothèses exigeant un modèle de déploiement différent.
À l’inverse, des démonstrations continues sans preuves de sécurité plus claires laisseraient ouverte la question des charges de travail sensibles. La réussite des tâches ne peut pas combler cette lacune, quelle que soit la qualité de l’interface.
Deuxièmement, vérifiez que les intégrations d’agents rendent leur couverture explicite et la maintiennent au fil des mises à jour. Les utilisateurs devraient pouvoir déterminer quelles opérations entrent dans l’environnement externe et lesquelles conservent l’autorité de l’hôte.
Ce signal importe particulièrement lorsque les outils empruntent des routes différentes. Une documentation claire sur la couverture renforcerait la confiance dans le périmètre déclaré de l’intégration. Des replis locaux inexpliqués ou un routage ambigu l’affaibliraient.
La compatibilité nécessite également un suivi. Une intégration peut dépendre d’un comportement extérieur à l’implémentation de la sandbox elle-même. Les équipes ont besoin de preuves que la combinaison prise en charge continue de se comporter comme documenté après la modification de l’un ou l’autre composant.
Troisièmement, vérifiez que le travail ordinaire tient dans des politiques d’autorisation compréhensibles. Un prototype est plus facile à exploiter avec confiance lorsque les utilisateurs peuvent expliquer pourquoi chaque autorisation de répertoire et de réseau existe.
Un rapport d’adoption utile décrirait la tâche et les autorisations qu’elle a exigées. Il identifierait aussi les opérations bloquées, les problèmes de compatibilité et les exceptions ajoutées pour terminer le travail. L’achèvement seul laisserait trop de zones inexpliquées.
Ces signaux ancrent l’évaluation dans le concret. Les tests indépendants traitent la résistance aux usages abusifs. La clarté du routage traite le périmètre de l’application. La facilité d’utilisation des autorisations traite la capacité des personnes à préserver ce périmètre tout en réalisant un travail utile.
Les sandboxes externes pour les agents de programmation offrent une manière concrète d’étudier ces questions sans considérer le modèle comme le seul décideur de la sécurité. Leur valeur repose sur la capacité à rendre l’autorité visible et applicable à la frontière d’exécution.
Pour les développeurs qui évaluent cette publication, commencez avec un projet jetable et une tâche clairement définie. Consignez les opérations qui doivent appartenir à la sandbox et les capacités qui restent sur l’hôte. Comparez les autorisations nécessaires à l’achèvement avec celles accordées initialement. Considérez les demandes d’accès plus étendu comme des informations sur le flux de travail, plutôt que comme un bruit de configuration habituel. Examinez à la fois le code obtenu et les actions réalisées pour le produire. Vérifiez ensuite si la même tâche reste réalisable sous les restrictions prévues. Ce processus révélera davantage qu’une capture d’écran réussie du terminal. Avant d’élargir l’accès d’un agent, votre équipe peut-elle expliquer ce qui reste protégé lorsque l’agent prend la mauvaise décision ?



