SPACE de Perplexity transforme les sandboxes Firecracker en infrastructure open source à tester
SPACE est une plateforme Apache-2.0 qui exécute du code d’agents et d’utilisateurs dans des microVM Firecracker. Son API est prometteuse pour les équipes qui ont besoin d’une véritable frontière d’exécution, mais l’installation locale reste propre à Linux et comporte encore plusieurs angles opérationnels délicats.
La pile open source des agents a passé une bonne partie de l’année écoulée à débattre des permissions, de l’approbation des outils et de l’injection de prompts. Une question plus discrète est tout aussi importante : où le code s’exécute-t-il réellement lorsqu’un agent écrit un script, installe un paquet ou lance un serveur ?

SPACE, de Perplexity, cherche à faire de cette couche d’exécution un composant open source réutilisable. Le projet se présente comme une « plateforme sandboxée pour l’exécution de code agentique » et publie un dépôt Apache-2.0 autour d’un service qui crée des microVM Firecracker isolées, y exécute des commandes et gère leur cycle de vie au moyen d’une API HTTP.
Cela rend SPACE intéressant pour une autre raison qu’un nouvel agent de programmation. Il fournit l’infrastructure de la partie d’un workflow agentique que l’on a le plus tendance à sous-estimer : la frontière entre des instructions générées et un véritable système d’exploitation. Le projet mérite d’être testé si vous développez une plateforme d’agents, un service capable d’exécuter du code ou un système d’automatisation interne. Ce n’est pas encore un utilitaire de bureau que l’on utilise sans préparation, et la documentation actuelle le montre clairement.
Ce que fournit réellement SPACE
SPACE n’est ni un modèle, ni un framework d’agents, ni un assistant de terminal. Une application appelle son API pour créer une sandbox à partir d’un modèle, attend que l’environnement soit prêt, démarre une session de commandes et lit le flux d’événements produit. La sandbox possède sa propre machine virtuelle et son propre système de fichiers accessible en écriture. Plusieurs commandes peuvent donc partager un état pendant une même exécution, au lieu de démarrer dans des processus ponctuels sans lien entre eux.
La documentation actuelle du dépôt identifie la version 0.8.0 et sépare l’API de gestion du plan de données utilisé pour les connexions aux commandes. Cette séparation est importante. Le client utilise un jeton bearer pour les requêtes de gestion, tandis qu’un flux de commandes utilise un jeton d’attachement renvoyé pour cette session. Le premier exemple de sandbox est volontairement implémenté avec la bibliothèque standard de Python ; le projet n’impose pas de SDK pour tester le parcours de base — création, exécution et suppression.
L’abstraction utile reste donc assez réduite :
application
-> créer une sandbox à partir d’un modèle
-> attendre une microVM en fonctionnement
-> créer une session de commandes
-> se connecter aux événements des commandes
-> recueillir la sortie et le code de sortie
-> supprimer ou conserver la sandbox
Cette approche convient mieux à un service d’agents que l’accès direct d’un modèle au shell de la machine hôte. L’agent peut toujours recevoir une interface de commandes, mais le processus, le système de fichiers et la politique réseau résident dans un environnement d’exécution géré séparément. SPACE permet également à l’application de décider combien de temps une sandbox doit rester active et quel état doit être conservé entre les commandes.
Pourquoi Firecracker change le compromis
Les conteneurs traditionnels sont efficaces parce que les processus partagent le noyau de l’hôte. C’est pratique, mais cela signifie aussi qu’une évasion de conteneur, une vulnérabilité du noyau ou une intégration dangereuse avec l’hôte peuvent avoir des conséquences qui dépassent le processus à l’origine de la charge de travail. Les conteneurs restent utiles et peuvent être largement renforcés ; ils ne sont pas automatiquement dangereux. Ils offrent simplement une frontière d’isolation différente de celle d’une machine virtuelle.
Firecracker adopte une approche plus étroite de la machine virtuelle. Sa documentation de conception décrit les microVM comme combinant l’isolation de la virtualisation matérielle avec une empreinte opérationnelle comparable à celle d’un conteneur. Un invité exécute son propre noyau, tandis que le processus Firecracker est à son tour limité par des mécanismes tels que les filtres seccomp, les espaces de noms, les cgroups et l’abandon des privilèges. SPACE utilise cette frontière de microVM comme cœur de son modèle de sandbox, au lieu de considérer un conteneur classique comme barrière de sécurité finale.
Cela ne rend pas le système miraculeusement sûr. Une microVM possède toujours une surface de périphériques virtuels, un VMM côté hôte, une passerelle réseau, la gestion des images et des modèles, des identifiants, de l’orchestration et une API de contrôle. Chaque couche peut contenir des bugs ou des erreurs de configuration. L’avantage est que la frontière est explicite et peut être testée indépendamment du modèle qui a produit le code.
Pour les charges de travail qui exécutent surtout de courts scripts, inspectent des dépôts non fiables, compilent du code généré ou exécutent des extraits soumis par des utilisateurs, cette distinction architecturale compte réellement. Elle fournit à l’équipe d’ingénierie un emplacement où définir des limites de ressources et des règles de sortie réseau, avant que ces contrôles ne se dispersent dans chaque intégration d’agent.
L’approche open source du projet est concrète
SPACE est distribué sous licence Apache-2.0, une licence permissive qui autorise l’utilisation, la modification et la redistribution du logiciel, sous réserve de ses conditions. Cette licence compte, car il est difficile d’évaluer une infrastructure de bac à sable lorsque le plan de contrôle critique est dissimulé derrière un service hébergé. Un dépôt public permet aux équipes d’examiner l’API, les scripts de déploiement, le chemin réseau et les composants d’exécution avant de décider si la conception mérite leur confiance.
Le dépôt est aussi bien plus qu’une fine couche autour de Firecracker. Sa documentation couvre un déploiement local avec Kind, un modèle initial, les services d’API et de plan de données, les services de nœud, l’authentification, le stockage et une interface web. Cette ampleur aide à comprendre comment se construit une plateforme complète de bacs à sable. Elle explique aussi pourquoi la première installation ressemble davantage au déploiement d’un petit produit d’infrastructure qu’à l’installation d’un outil en ligne de commande.
Open source ne signifie pas certification de sécurité. L’état des versions, le suivi des problèmes et les instructions de déploiement du dépôt doivent être considérés comme des indicateurs de maturité du projet. Une équipe qui adopte SPACE devrait verrouiller une révision connue, examiner les changements touchant les chemins réseau et les identifiants, et maintenir le service à l’écart des secrets de production tant qu’il n’a pas été testé selon son propre modèle de menace.
Qui devrait l’essayer maintenant
Le public le mieux placé au départ est une équipe confrontée à un problème d’exécution concret et disposant d’une expérience suffisante de l’infrastructure Linux pour mesurer les compromis.
Une plateforme d’agents en est l’exemple le plus évident. Si un agent doit exécuter des tests, transformer des fichiers, construire un projet ou utiliser un outil semblable à un navigateur, SPACE peut fournir un environnement par session au lieu d’exposer le worker hôte. L’application reste chargée de décider quels outils sont disponibles, quels fichiers sont montés ou copiés, si le bac à sable peut accéder à Internet et à quel moment les résultats peuvent franchir la frontière.
Un service d’évaluation de code constitue un autre cas d’usage adapté. La plateforme peut créer un environnement vierge à partir d’un modèle contrôlé, exécuter une soumission, capturer stdout et stderr, imposer un délai maximal, puis supprimer le résultat. Le même schéma s’applique à l’analyse de dépôts, à la reproduction automatisée de bogues et aux tâches de compilation isolées lorsque les entrées ne sont pas entièrement fiables.
SPACE peut également convenir à des équipes d’automatisation internes qui souhaitent expérimenter avec des scripts générés par des agents sans lier leur conception à un fournisseur de modèles particulier. Comme le service est accessible par une API, le modèle peut changer tandis que la couche d’exécution reste relativement stable.
SPACE n’est pas le meilleur premier choix pour un développeur qui veut simplement utiliser un assistant de programmation local. La configuration exige KVM, les fonctions réseau de Linux, Docker, des outils Kubernetes-in-Docker et une machine capable d’exécuter des charges privilégiées. Pour un usage personnel dans le terminal, un conteneur local ou un service de bac à sable existant peut être plus simple à exploiter, selon la sensibilité du code.
L’installation locale est le premier filtre sérieux
Le guide officiel décrit clairement la forme prise par le déploiement local actuellement pris en charge. Il cible une machine Linux x86_64 basée sur apt, avec KVM. La machine doit disposer de /dev/kvm, de /dev/net/tun, de périphériques loop et de la prise en charge de btrfs, ainsi que d’un démon Docker autorisant les conteneurs privilégiés. Les instructions ne constituent pas une configuration directe pour macOS et ne sont pas présentées comme une installation sans Kubernetes.
Le déploiement utilise un cluster Kind et publie un modèle initial avant de pouvoir créer le premier bac à sable. Le guide demande d’installer ou de vérifier des outils comme Kind, kubectl, Helm, grpcurl, Tilt, Go et jq. La compilation initiale construit l’espace de travail Rust et crée le modèle, tandis que le cluster expose des chemins locaux distincts pour l’API, le plan de données, l’interface utilisateur et le stockage d’objets.
Ce ne sont pas des tâches accessoires autour du projet. Elles font partie intégrante de SPACE. Le système a besoin d’un plan de contrôle, de services de nœud, d’un gestionnaire de modèles, d’un gestionnaire de bacs à sable et d’une configuration du fournisseur Firecracker avant qu’un invité puisse démarrer. Un déploiement réussi des pods ne suffit pas : le job de publication du modèle initial et chaque déploiement des services de nœud doivent également se terminer avant que l’exemple de premier bac à sable ait un sens.
La documentation contient un avertissement précisant que le déploiement local utilise des mots de passe et des clés de signature de développement, et qu’il doit rester privé. Cet avertissement doit être considéré comme une limite stricte. Une configuration de démonstration locale n’est pas un système d’identité destiné à la production, et exposer ses points de terminaison ou réutiliser ses valeurs par défaut viderait l’exercice de son intérêt.
WSL2 et le réseau ne sont pas de simples détails
Le suivi des problèmes montre déjà pourquoi l’affirmation « cela fonctionne dans mon environnement de type Linux » ne suffit pas comme garantie de compatibilité. Un rapport du 18 octobre décrit une installation sous Windows 11 et WSL2 où la vérification documentée de l’hôte a réussi, mais où les étapes suivantes ont échoué pour trois raisons différentes : Docker Buildx était absent, la limite inotify par défaut était trop basse pour le cluster Kind, et le noyau WSL2 standard ne disposait pas de la prise en charge de CONFIG_NFT_SOCKET requise par le chemin réseau TPROXY du projet.
Le rapport indique que les deux premiers problèmes avaient des solutions de contournement, tandis que l’absence de cette capacité du noyau empêchait le démarrage des bacs à sable avec le noyau WSL2 standard. Les développeurs Windows ne devraient donc pas considérer WSL2 comme une cible couramment prise en charge simplement parce que les commandes Linux et KVM semblent disponibles. La question pratique est de savoir si le noyau et le chemin réseau satisfont exactement aux exigences de la passerelle du bac à sable.
Un autre problème ouvert décrit un mode de défaillance moins évident sur les hôtes où net.ipv4.conf.all.src_valid_mark=1, un réglage souvent associé au routage Tailscale ou WireGuard. Dans la configuration signalée, la sortie réseau du bac à sable échouait silencieusement, même avec une politique autorisant tout le trafic. Les requêtes DNS expiraient, les connexions TCP n’aboutissaient pas et la passerelle ne fournissait aucune indication utile sur la cause. L’auteur du problème a attribué ce comportement à la manière dont l’espace de noms réseau du bac à sable gérait la marque TPROXY et a proposé d’effacer ce réglage à l’intérieur de l’espace de noms.
Ces rapports ne prouvent pas que SPACE est dangereux. Ils montrent que la couche réseau a une importance opérationnelle réelle et que le projet découvre encore des combinaisons d’hôtes qui devraient être signalées plus tôt par les vérifications préalables. Pour un déploiement en production, une commande hello-world réussie ne suffit pas. Testez la sortie réseau interdite, la sortie autorisée, le DNS, les délais d’expiration, le nettoyage des espaces de noms et la récupération après le redémarrage d’un nœud ou de la passerelle.
Comment évaluer la limite de sécurité
Le bon test ne consiste pas à vérifier qu’un agent peut exécuter echo hello. Il faut déterminer si le système se comporte de manière prévisible lorsque la charge est hostile, bruyante ou défaillante.
Commencez avec un modèle vierge et vérifiez que l’invité ne peut pas accéder aux fichiers de l’hôte, aux identifiants de l’hôte ni au socket Docker. Confirmez que le processus s’exécute avec l’utilisateur prévu et que les limites configurées de mémoire, de processeur, de disque et de durée sont effectivement appliquées. Essayez de créer des processus enfants persistants, de remplir le système de fichiers et d’ouvrir davantage de descripteurs de fichiers que la charge normale ne devrait en nécessiter. L’objectif est de vérifier que les limites entraînent un échec contrôlé plutôt qu’un nœud instable.
Testez le réseau comme une surface de politique. Si le bac à sable est censé n’avoir aucune sortie réseau, vérifiez le DNS, IPv4, IPv6, la boucle locale et les variables d’environnement courantes liées aux proxys. Si une sortie ciblée est autorisée, testez les destinations permises et refusées, puis vérifiez si l’échec est visible par l’appelant. Une politique qui bloque correctement mais ressemble à une commande bloquée sera difficile à exploiter dans une boucle d’agent.
Considérez la construction des modèles comme un travail de chaîne d’approvisionnement. Un modèle n’est pas seulement une image pratique : c’est le système de fichiers initial du code potentiellement non fiable. Construisez-le à partir d’entrées verrouillées, enregistrez son condensat et, lorsque c’est possible, séparez l’installation des paquets de la requête d’exécution. N’autorisez pas un agent à réécrire le modèle de base ni à modifier le processus de construction côté hôte.
Enfin, testez séparément le plan de contrôle et l’invité. Faites tourner les jetons, rejetez les URL de pièces jointes malformées, imposez l’origine attendue du plan de données et vérifiez qu’un bac à sable supprimé ne peut pas être contacté au moyen d’un identifiant obsolète. La séparation entre les jetons de gestion et les jetons d’attachement aux commandes, présentée dans le guide du premier bac à sable, fournit une piste de conception utile : les identifiants doivent être limités à l’opération qu’ils autorisent.
Comparaison de SPACE avec les alternatives
Un conteneur Docker ou Podman classique reste l’option la plus simple lorsque la charge est fiable, que l’hôte est mono-tenant et que l’équipe a surtout besoin de packaging. Il est plus facile à exécuter localement et s’intègre aux outils OCI existants. Il ne faut toutefois pas le présenter comme interchangeable avec une microVM Firecracker lorsque le modèle de menace inclut du code arbitraire fourni par des utilisateurs ou des agents.
gVisor est une autre solution open source. Son architecture fondée sur un noyau applicatif intercepte une grande partie des interactions du conteneur avec le noyau hôte et s’intègre à Docker et Kubernetes grâce au runtime OCI runsc. Elle permet de conserver davantage du fonctionnement habituel des conteneurs tout en ajoutant une couche d’isolation distincte. En contrepartie, elle présente un profil différent en matière de compatibilité et de performances, et ne fournit pas le même modèle de noyau invité qu’une microVM.
Daytona constitue une autre comparaison utile pour les équipes qui recherchent avant tout un produit de sandbox prêt à l’emploi. Sa documentation décrit des sandboxes conteneurisées par défaut et propose aussi des sandboxes fondées sur des machines virtuelles, avec des SDK et des opérations de cycle de vie directement conçus pour les charges de travail d’agents. Cela peut réduire la quantité d’infrastructure à assembler, mais une plateforme hébergée ou conçue comme un produit modifie les questions de contrôle, de tarification et d’auto-hébergement. SPACE devient plus intéressant lorsque la maîtrise du plan de contrôle et l’inspection de l’implémentation sont des exigences centrales.
Firecracker lui-même n’est pas une alternative à SPACE au même niveau. Firecracker est le moniteur de machines virtuelles et le runtime bas niveau ; SPACE est la plateforme qui l’entoure, avec notamment la sémantique de l’API, les modèles, l’orchestration, le stockage et la gestion du réseau. Une équipe qui construit directement sur Firecracker bénéficie de davantage de contrôle, mais assume aussi davantage de responsabilités. Une équipe qui adopte SPACE dispose d’un point de départ plus complet et reprend son architecture actuelle ainsi que ses hypothèses opérationnelles.
Ce qu’il est possible de tester, et ce qui ne l’est pas encore
Le projet se prête à une évaluation structurée, pas à un déploiement aveugle en production. Les ressources actuellement disponibles suffisent pour créer un déploiement local dans Kind, publier le modèle de départ, s’authentifier et exécuter une commande dans une sandbox reposant sur Firecracker. La frontière de l’API est suffisamment claire pour prototyper un exécuteur d’agent sans s’engager sur un modèle ou un SDK client particulier.
Le projet n’est pas encore un outil de développement multiplateforme sans friction. Le parcours local documenté cible Linux x86_64 et dépend de capacités bas niveau de l’hôte. Le suivi des problèmes montre que WSL2 et le routage lié aux VPN peuvent provoquer des échecs qui ne sont pas évidents lors de la première vérification de l’hôte. L’infrastructure comporte également suffisamment de composants interdépendants pour que les mises à niveau soient traitées comme des changements de déploiement, avec des tests reproductibles pour les modèles, le réseau, l’identité et l’état conservé.
La première expérimentation devrait rester limitée. Déployez SPACE sur un hôte Linux jetable, utilisez un modèle hors production et développez un client de test capable d’effectuer un cycle de vie complet. Mesurez le délai de création, le temps de démarrage de la commande, la livraison de la sortie, le temps de nettoyage et le comportement en cas d’échec. Exécutez la même charge de travail avec accès réseau refusé, puis autorisé. Cassez ensuite volontairement les prérequis de l’hôte et vérifiez que les contrôles échouent avant un long bootstrap, plutôt qu’après une demande de sandbox.
Pour un produit fondé sur des agents, ajoutez une couche autour de SPACE au lieu d’exposer directement l’API brute au modèle. Votre service devrait choisir le modèle de sandbox à utiliser, émettre des identifiants temporaires aux permissions limitées, ne copier que les entrées nécessaires, plafonner l’utilisation des ressources, masquer les éléments sensibles dans la sortie et conserver un journal d’audit à l’extérieur de l’invité. La sandbox réduit l’ampleur d’un incident ; elle ne décide pas si l’agent était autorisé à effectuer l’action au départ.
La leçon open source plus large
SPACE est utile même pour les équipes qui ne le déploieront jamais. Le projet rend visible la frontière d’exécution. Un agent capable de modifier des fichiers et d’exécuter des commandes n’est pas simplement une interface de conversation dotée de quelques boutons supplémentaires : c’est un ordonnanceur de charges de travail, un consommateur d’identifiants et un runtime sensible du point de vue de la sécurité. Isoler ce runtime dans un projet distinct donne au reste de la pile une interface concrète à tester.
Le moment est également bien choisi. Les projets d’agents open source se sont souvent concentrés sur l’orchestration, le routage des modèles et les schémas d’outils. Ces couches sont visibles pour les utilisateurs, tandis que la sandbox reste généralement cachée derrière un fournisseur cloud ou une machine de développement. SPACE met cette couche dissimulée au premier plan : Firecracker, KVM, les règles réseau, les modèles, les flux d’événements et les prérequis de l’hôte deviennent des éléments de l’architecture applicative.
C’est pourquoi le projet mérite une place dans la veille open source, avec une réserve essentielle. Sa promesse n’est pas qu’un dépôt ouvert élimine les risques. Elle est qu’une équipe d’ingénierie peut inspecter, exécuter et améliorer une frontière critique au lieu de l’accepter comme un service opaque. En version 0.8.0, le meilleur usage consiste à tester cette frontière avec soin, à documenter les échecs et à déterminer si le coût opérationnel se justifie par le niveau d’isolation réellement nécessaire à votre charge de travail.
Comments
Sign in to comment.
No comments yet.