Un agent de programmation peut modifier des fichiers, exécuter des commandes et installer des dépendances. Dans un environnement de développement classique, ces actions peuvent toucher davantage de ressources que nécessaire. Eclipse Enclave 1.0 répond à ce problème en exécutant les agents dans des conteneurs isolés, avec des accès définis à l’avance.
La version 1.0, annoncée par la Eclipse Foundation le 19 novembre 2026, prend notamment en charge Claude Code, Codex et OpenCode. Elle fournit une passerelle qui filtre les connexions réseau et journalise les destinations tentées. Ce tutoriel explique comment préparer l’environnement, lancer un agent, limiter ses accès et contrôler les modifications avant leur fusion.
Étape 1 : Vérifier les prérequis avant l’installation
Enclave 1.0 est un runtime et une sandbox open source distribués sous licence MIT. Le projet est conçu pour exécuter des agents de programmation dans des conteneurs isolés et prend en charge Docker et Podman, avec un fonctionnement rootless indiqué pour ces deux moteurs.
Avant de commencer, préparez :
- Un ordinateur de développement compatible avec Docker ou Podman.
- Un projet local que l’agent pourra modifier.
- Un agent de programmation pris en charge, comme Claude Code, Codex ou OpenCode.
- Les identifiants nécessaires à l’agent utilisé.
- Un terminal pour exécuter les commandes d’installation et de lancement.
- Une connexion réseau si l’agent doit télécharger des dépendances ou consulter des ressources autorisées.
Enclave n’est pas présenté comme un service hébergé nécessitant un abonnement mensuel. La version 1.0 est disponible comme logiciel open source sous licence MIT. En revanche, l’agent exécuté dans Enclave peut dépendre de son propre compte, de son propre abonnement ou de ses propres identifiants.
Attention : l’isolation ne dispense pas de vérifier les changements produits par l’agent. Les développeurs restent responsables de l’examen du code avant toute fusion.
Étape 2 : Télécharger Enclave 1.0
Ouvrez le site du projet Enclave et accédez à la documentation ou à la page de téléchargement. Sélectionnez la version stable 1.0 plutôt qu’un canal de développement, puis suivez les instructions adaptées à votre système et à votre moteur de conteneurs.
Dans un terminal, commencez par vérifier la présence du moteur choisi :
bash docker --version
ou :
bash podman --version
La commande doit afficher une version installée. Si elle échoue, installez d’abord Docker ou Podman en suivant la documentation officielle du moteur concerné, puis redémarrez le terminal.
Téléchargez ensuite Enclave depuis le site officiel du projet. Le dépôt public de l’organisation Eclipse Enclave regroupe les composants du projet, tandis que la documentation fournit les instructions de démarrage et les options disponibles.
Astuce : conservez la configuration dans un répertoire consacré au projet. Vous pourrez ainsi versionner les règles d’accès avec le code et reproduire facilement une session d’agent.
Étape 3 : Préparer un projet de test
Ne commencez pas avec un dépôt contenant des clés privées, des fichiers de production ou des données clients. Créez plutôt un projet d’essai comprenant une application simple et quelques tests.
Par exemple, placez-vous dans un répertoire de travail :
bash mkdir enclave-demo cd enclave-demo git init printf "# Enclave demo\n" > README.md git add README.md git commit -m "Initialiser le projet de démonstration"
L’objectif est de disposer d’un état initial vérifiable. Si l’agent modifie le projet, la comparaison avec le commit de départ permettra de repérer rapidement les changements.
Ajoutez un fichier de consignes destiné à l’agent :
text Objectif : ajouter une fonction de validation d'adresse e-mail. Contraintes : ne modifier que les fichiers du projet, ne supprimer aucun test, expliquer chaque changement et exécuter la suite de tests avant de terminer.
Cette consigne ne remplace pas les politiques d’Enclave. Elle complète les restrictions techniques par des règles de travail compréhensibles par l’agent.
À retenir : un dépôt de test et un historique Git propre rendent les erreurs réversibles et facilitent l’audit de la session.
Étape 4 : Définir les fichiers accessibles
Le principe central d’Enclave consiste à donner à l’agent uniquement les ressources utiles à sa tâche. Une session est exécutée dans un conteneur isolé, avec des accès contrôlés aux fichiers, aux réseaux et aux ressources de développement.
Commencez par autoriser le répertoire du projet. N’exposez pas automatiquement votre dossier personnel complet. Évitez notamment de monter les répertoires qui contiennent des clés SSH, des fichiers de configuration cloud ou des jetons d’API.
Une politique de départ peut suivre ce modèle conceptuel :
yaml project: path: ./enclave-demo mode: read-write
files: read-only:
- ./docs denied:
- ~/.ssh
- ~/.aws
- ~/.config
Adaptez la syntaxe exacte à la configuration attendue par Enclave 1.0 dans la documentation du projet. Les noms de champs ci-dessus illustrent la logique à appliquer : le code de travail est modifiable, la documentation peut être en lecture seule et les répertoires sensibles restent interdits.
Pour une tâche de lecture ou d’analyse, choisissez un accès en lecture seule lorsque cela est possible. Pour une tâche de correction, limitez l’accès en écriture au dépôt concerné.
Attention : un fichier monté en lecture seule peut encore révéler des informations sensibles à l’agent. L’absence d’écriture ne signifie pas absence de confidentialité.
Étape 5 : Choisir l’agent de programmation
Enclave 1.0 prend en charge Claude Code, Codex, OpenCode et d’autres agents grâce à une architecture extensible. Sélectionnez l’agent déjà utilisé par votre équipe, puis vérifiez qu’il peut être lancé depuis le terminal dans l’environnement préparé.
Testez d’abord l’installation en dehors d’une tâche sensible. Par exemple, demandez à l’agent d’afficher la structure du projet sans modifier de fichier :
text Affiche la liste des fichiers du projet. Ne crée, ne modifie et ne supprime aucun fichier.
Vérifiez ensuite que l’agent répond correctement et qu’il utilise les identifiants attendus. Si l’agent réclame un jeton ou une connexion, fournissez uniquement le secret nécessaire à la session.
Évitez de copier directement une clé dans une consigne. Préférez le mécanisme de secrets prévu par Enclave et par l’agent utilisé. Une règle de bon sens consiste à transmettre un secret limité dans le temps et limité aux opérations nécessaires.
Astuce : commencez chaque nouvelle intégration par une tâche sans écriture. Cette étape permet de vérifier l’agent, le montage des fichiers et la connectivité avant d’autoriser des modifications.
Étape 6 : Configurer la passerelle réseau
La passerelle réseau d’Enclave filtre les connexions de l’agent et journalise les destinations tentées. Cette fonction permet de réduire les communications sortantes et de conserver une trace des hôtes demandés pendant la session.
Pour une modification locale qui ne nécessite aucun téléchargement, bloquez les connexions externes. Pour une installation de dépendances, autorisez uniquement les registres ou services indispensables.
Une politique illustrative peut ressembler à ceci :
yaml network: default: deny allow:
- registry.npmjs.org
- pypi.org
Remplacez ces destinations par celles réellement nécessaires à votre projet. N’autorisez pas un domaine général lorsque le gestionnaire de paquets ou l’outil utilisé permet une liste plus restreinte.
Demandez ensuite à l’agent de réaliser une opération contrôlée :
text Analyse les dépendances du projet. N'installe rien pour le moment et indique les domaines réseau qui seraient nécessaires.
Consultez le journal de la session pour vérifier les destinations tentées. Une connexion inattendue doit être traitée comme un signal d’arrêt : interrompez l’agent, examinez la demande et ajustez la politique uniquement si cette connexion est légitime.
À retenir : la passerelle ne rend pas une connexion sûre par défaut. Elle permet de décider quelles connexions sont autorisées et de voir quelles destinations l’agent a tenté d’atteindre.
Étape 7 : Lancer une première session en lecture seule
Avant d’autoriser l’écriture, lancez une session limitée à l’observation. La première consigne doit être suffisamment précise pour vérifier les frontières de l’environnement.
Copiez-collez par exemple :
text Tu travailles dans un environnement isolé.
- Liste les fichiers accessibles.
- Indique le répertoire de travail courant.
- Vérifie si la suite de tests existe.
- Ne modifie aucun fichier.
- Ne contacte aucun service externe.
Comparez la réponse de l’agent avec la politique définie. Il doit voir le projet nécessaire, mais pas les répertoires explicitement exclus. Si l’agent signale une ressource indispensable qui n’est pas accessible, ajoutez-la de manière ciblée plutôt que d’élargir toute la zone de montage.
Cette session sert aussi à vérifier la séparation entre l’environnement hôte et le conteneur. L’agent doit travailler dans l’espace qui lui est attribué et non dans l’ensemble du système.
Attention : une sandbox réduit le périmètre d’action, mais elle ne transforme pas automatiquement une instruction ambiguë en tâche sûre. Décrivez toujours les fichiers autorisés, les opérations interdites et le résultat attendu.
Étape 8 : Autoriser une modification contrôlée
Une fois la session de lecture validée, autorisez l’écriture uniquement sur le dépôt de test. Demandez une tâche courte, mesurable et réversible.
Exemple de prompt :
text Ajoute une fonction de validation d'adresse e-mail dans le projet. Contraintes :
- modifie uniquement les fichiers du dépôt courant ;
- ne touche pas aux fichiers de configuration de l'utilisateur ;
- n'installe aucune dépendance sans demander une autorisation explicite ;
- ajoute des tests pour les cas valide, invalide et vide ;
- exécute les tests existants ;
- résume les fichiers modifiés et les commandes exécutées.
Laissez l’agent travailler dans le conteneur isolé, puis examinez sa sortie. Vérifiez les fichiers modifiés avec Git :
bash git status --short git diff --stat git diff
Contrôlez notamment les changements inattendus, les nouveaux fichiers, les dépendances ajoutées et les modifications de configuration. Une tâche réussie est une tâche dont le résultat est compréhensible et dont le périmètre correspond à la consigne.
Astuce : imposez une sortie structurée à l’agent : résumé, fichiers modifiés, tests exécutés, erreurs rencontrées et prochaines actions. Cette habitude accélère la revue humaine.
Étape 9 : Autoriser les dépendances avec une liste blanche
Certains agents doivent installer une dépendance ou télécharger une documentation. Cette opération combine deux contrôles : le droit d’écrire dans le projet et le droit de contacter un registre ou un service précis.
Commencez par demander à l’agent de préparer l’opération sans l’exécuter :
text Identifie les dépendances manquantes pour exécuter les tests. Ne lance aucune installation. Donne le nom du paquet, sa version demandée, le gestionnaire utilisé et le domaine réseau requis.
Examinez la proposition. Si elle est acceptable, autorisez le registre nécessaire dans la passerelle, puis donnez une instruction limitée :
text Installe uniquement les dépendances listées dans la commande approuvée. N'ajoute aucun paquet supplémentaire. Affiche la commande avant exécution, puis exécute les tests et résume le résultat.
Surveillez le journal réseau pendant l’installation. Une dépendance peut déclencher plusieurs connexions indirectes, notamment vers des services de téléchargement ou de contrôle de version. La liste blanche doit donc être testée dans un environnement non critique avant un usage régulier.
Étape 10 : Exécuter plusieurs agents sans mélanger les tâches
Enclave permet d’exécuter des sessions d’agents de manière indépendante et, selon l’organisation retenue, de traiter plusieurs tâches en parallèle. Chaque tâche doit disposer de son propre espace de travail afin d’éviter les modifications concurrentes sur les mêmes fichiers.
Créez par exemple une branche ou une copie de travail pour chaque mission :
bash git switch -c agent-validation-email git worktree add ../enclave-tests agent-tests
Attribuez ensuite une mission distincte à chaque session :
- Session A : ajouter la validation d’adresse e-mail.
- Session B : écrire des tests de régression.
- Session C : documenter l’API existante.
Ne donnez pas simultanément à deux agents l’autorisation d’écrire dans les mêmes fichiers. Une isolation par conteneur ne résout pas les conflits logiques entre modifications concurrentes.
Lorsque les sessions sont terminées, comparez chaque branche séparément. Fusionnez uniquement les changements examinés et testés.
Étape 11 : Reprendre une session et examiner les journaux
Enclave est conçu pour permettre la reprise de sessions précédentes. Utilisez cette possibilité pour éviter de redonner un accès large à l’agent lors d’une tâche interrompue, mais vérifiez l’état de la session avant de la reprendre.
Commencez par consulter :
- Les fichiers modifiés depuis la dernière exécution.
- Les commandes déjà lancées.
- Les destinations réseau tentées.
- Les erreurs rencontrées.
- Les permissions actuellement appliquées.
Demandez à l’agent de reprendre avec une consigne explicitement limitée :
text Reprends la tâche à partir de l'état actuel. Commence par résumer ce qui a déjà été fait. Ne modifie aucun fichier tant que tu n'as pas identifié les tests restants. N'élargis pas les accès aux fichiers, aux secrets ou au réseau.
La reprise ne doit pas devenir une autorisation implicite. Si la tâche change, créez une nouvelle politique ou une nouvelle session adaptée à ce nouveau besoin.
Étape 12 : Vérifier puis fusionner le résultat
La dernière étape ne consiste pas à accepter la réponse de l’agent, mais à vérifier le résultat dans le dépôt. Examinez le diff, lancez les tests et contrôlez les fichiers générés.
Utilisez une séquence simple :
bash git diff --check
bash
Lancez ici la commande de test propre à votre projet
Puis inspectez les changements :
bash git status --short git diff
La revue doit vérifier :
- La conformité avec la tâche demandée.
- L’absence de secret ou de donnée sensible dans les fichiers modifiés.
- La présence de tests pertinents.
- La compatibilité avec les conventions du projet.
- L’absence de dépendance ou de permission ajoutée sans justification.
- La cohérence entre les journaux réseau et les accès autorisés.
Une fois la revue terminée, faites relire le changement par un autre développeur lorsque le projet est sensible, puis fusionnez la branche selon votre processus habituel.
À retenir : Enclave encadre l’exécution de l’agent, mais la fusion reste une décision humaine. L’isolement réduit le rayon d’action ; il ne valide ni la qualité ni la sécurité du code produit.
Ce qu’Enclave change face à une exécution directe
Enclave ajoute une couche de contrôle entre l’agent et l’environnement de développement. Le tableau suivant résume les différences opérationnelles les plus importantes.
| Aspect | Agent lancé directement | Agent exécuté avec Enclave 1.0 |
|---|---|---|
| Environnement d’exécution | Système de développement de l’utilisateur | Conteneur isolé |
| Accès aux fichiers | Dépend des permissions disponibles au processus | Ressources définies par la politique |
| Accès réseau | Dépend de la configuration locale et de l’outil | Filtré par une passerelle |
| Suivi des destinations | Peut varier selon l’outil utilisé | Destinations tentées journalisées par la passerelle |
| Agents pris en charge | Dépend de chaque outil | Claude Code, Codex, OpenCode et intégrations extensibles |
| Exécution sans privilèges root | Dépend du moteur et de la configuration | Fonctionnement rootless avec Docker et Podman indiqué par le projet |
| Validation du code | À la charge de l’équipe | Toujours à la charge de l’équipe |
Cette comparaison ne signifie pas qu’Enclave supprime les risques. Une politique trop permissive, un secret mal exposé ou une revue insuffisante peuvent toujours créer un problème. Thabang Mashologu souligne que la plateforme permet de définir les accès sans demander une approbation pour chaque action, mais qu’elle ne supprime pas les risques.
Les erreurs à éviter dès la première session
Les mauvaises configurations viennent souvent d’un périmètre trop large plutôt que d’un défaut de l’agent lui-même.
- Monter tout le dossier personnel au lieu du seul dépôt utile.
- Autoriser l’accès réseau général pour installer une seule dépendance.
- Exposer une clé cloud permanente à une session de test.
- Lancer une modification sans commit de référence.
- Faire travailler deux agents sur les mêmes fichiers.
- Fusionner un changement sans lire le diff.
- Confondre un journal de connexions avec une preuve que le contenu échangé était sûr.
- Demander une tâche vague comme « améliore le projet » sans définir les fichiers et les critères de réussite.
Une politique minimale et restrictive est généralement plus facile à auditer qu’une longue liste d’exceptions ajoutées au fil des erreurs. Commencez par bloquer, observez le besoin réel, puis ouvrez un accès précis.
Notre avis : Enclave 1.0 convient aux équipes qui veulent tester l’autonomie sans ouvrir tout le poste
Enclave 1.0 est particulièrement pertinent pour les développeurs qui souhaitent laisser un agent exécuter plusieurs actions sans lui donner un accès général à leur machine. Son intérêt tient à la combinaison de trois mécanismes : conteneur isolé, accès déclarés aux fichiers et passerelle réseau avec journalisation.
Le projet ne remplace ni une revue de code, ni une gestion sérieuse des secrets, ni des tests automatisés. Il fournit plutôt un cadre commun pour faire travailler Claude Code, Codex, OpenCode et d’autres agents dans des limites explicites. La licence MIT et l’absence de coût logiciel annoncé pour Enclave 1.0 facilitent les essais, tandis que les coûts éventuels de l’agent, des infrastructures et des services utilisés restent séparés.
Pour une première mise en production, la stratégie la plus prudente consiste à commencer par des dépôts non sensibles, des tâches réversibles et une politique réseau restrictive. Après six mois d’usage, le vrai indicateur ne sera pas le nombre de tâches confiées à l’agent, mais la capacité de l’équipe à expliquer précisément ce qu’il pouvait lire, modifier et contacter lors de chaque session.
Jusqu’où les équipes accepteront-elles d’automatiser les changements lorsque chaque accès sera traçable, mais que la décision finale restera humaine ?