forkd : le projet Rust qui fork des micro-VM d'agents IA en 100 ms — le sandboxing agent repensé

forkd : le projet Rust qui fork des micro-VM d'agents IA en 100 ms — le sandboxing agent repensé

🔎 Le sandboxing d'agents IA venait de trouver son chaînon manquant

Le problème est connu : Docker est trop lourd pour les boucles d'agents, et l'isolation par processus est trop permissive. Entre les deux, il manquait un truc. En août 2026, un développeur publie forkd sur GitHub, et le projet explose dans les cercles d'ingénierie IA. Le concept ? Forker des micro-VM entières en sous-millisecondes grâce au copy-on-write mémoire de Linux, le tout packagé dans un binaire Rust de quelques mégaoctets.

La raison pour laquelle ça décolle maintenant : les agents de code sont passés du stade de démo à celui de production. Ils exécutent du code, modifient des fichiers, lancent des processus. Sans isolation réelle, c'est un désastre de sécurité. Avec les conteneurs classiques, c'est un désastre de performance. forkd arrive au moment exact où l'industrie réalise que le sandboxing est le goulot d'étranglement numéro un du déploiement d'agents à grande échelle.

L'essentiel

• forkd est un runtime open-source en Rust qui fork des micro-VM KVM (basées sur Firecracker) en ~0,8 ms par instance, avec seulement ~265 Ko de mémoire par fork.
• Le mécanisme repose sur un mapping MAP_PRIVATE qui délègue le copy-on-write au noyau Linux : pas de copie de pages, pas de serialization lourde.
• Deux opérations clés : fork() pour cloner un snapshot en micro-VM enfant, et branch() pour pauser une VM en cours, snapshotter son état en vol, et reprendre depuis ce point.
• Le projet est décrit comme un "e2b killer" par la communauté, visant directement les plateformes de sandboxing propriétaires.

Outils recommandés

L'architecture de forkd — du snapshot au fork en un appel système

L'idée fondamentale de forkd est simple : pourquoi recréer une VM from scratch à chaque itération d'un agent, alors qu'on peut cloner l'état d'une VM existante en un seul appel système ?

Tout part d'un snapshot initial. Une micro-VM Firecracker est démarrée une première fois, son environnement est préparé (dépendances, fichiers, état du filesystem), puis son état est sérialisé. Comme l'explique l'article de builders.cortex.io, cette serialization capture l'état du vCPU, les structures KVM et l'état des devices émulés dans un fichier compact.

Une fois ce snapshot en mémoire, la magie opère. forkd utilise un mapping MAP_PRIVATE sur la mémoire du snapshot, ce qui donne automatiquement au noyau Linux des pages en copy-on-write. Comme le détaille la discussion sur Hacker News (47412569), c'est le même mécanisme que le fork() Unix classique, mais appliqué à une VM entière.

Chaque enfant créé via fork() partage initialement 100 % des pages mémoire avec le parent. Seules les pages modifiées sont copiées, à la demande. Le post Reddit r/SideProject rapporte que chaque fork crée une nouvelle KVM VM en mappant la mémoire snapshot en CoW, le tout en ~0,8 ms.

La consommation mémoire est le vrai chiffre choc : ~265 Ko par sandbox enfant. Pas 265 Mo. 265 kilo-octets. C'est ce qui permet de forker 100 enfants en ~100 ms sans exploser la RAM du serveur.

fork() vs branch() — les deux primitives de forkd

forkd expose deux opérations distinctes, et la différence entre les deux est cruciale pour comprendre les cas d'usage.

fork() — cloner un snapshot à froid

fork() prend un snapshot existant et crée une micro-VM enfant qui démarre depuis cet état. C'est l'opération la plus rapide : ~0,8 ms par clone. L'enfant est une copie indépendante qui peut exécuter du code, modifier des fichiers, crasher — le parent n'est pas affecté.

Le cas d'usage typique : un agent de code qui doit tester 50 variantes d'un fix en parallèle. On prépare un snapshot avec le repo cloné et les dépendances installées, puis on fork 50 enfants. Chacun exécute sa variante. Résultats collectés, enfants détruits. Total : quelques dizaines de millisecondes.

branch() — snapshotter une VM en vol

branch() est plus subtil. Elle prend une VM en cours d'exécution, la pausé, snapshotte son état in-flight (processus lancés, fichiers ouverts, connections réseau actives), puis reprend une nouvelle VM depuis ce point exact. Temps rapporté : ~150 ms.

C'est l'opération qui intéresse le plus les développeurs d'agents itératifs. Imaginez un agent de code comme Grok Build, le premier agent coding CLI de xAI : l'agent a déjà passé 30 secondes à installer des dépendances et indexer un codebase. Plutôt que de recommencer depuis zéro pour chaque tentative de fix, on branche depuis l'état courant.

Le parallèle avec le framework Agent Skills d'Addy Osmani est intéressant : les workflows d'agents nécessitent des points de sauvegarde et de restauration. branch() fournit cette primitive au niveau infrastructure, pas au niveau applicatif.

Pourquoi Docker ne suffit plus pour les agents IA

Le conteneur, c'est l'isolation par cgroups + namespaces. Ça marche bien pour déployer des microservices. Mais pour les agents de code, ça coince sur trois points.

Premièrement, le temps de démarrage. Un conteneur Docker froid met 200 ms à 2 secondes selon la taille de l'image. Quand un agent comme Prime Agent itère des dizaines de fois par minute, ce coût devient rédhibitoire. forkd démarre un enfant en 0,8 ms — soit 250 à 2500 fois plus rapide.

Deuxièmement, la surface d'attaque. Un conteneur partage le noyau avec l'hôte. Un agent malveillant ou un prompt injection peut exploiter des vulnérabilités kernel pour s'échapper. Une micro-VM KVM, même légère, a son propre kernel virtuel. L'isolation est matérielle, pas logicielle. Le guide northflank sur le sandboxing d'agents le rappelle : pour l'exécution de code non fiable, les micro-VMs offrent un niveau de sécurité que les conteneurs ne peuvent pas égaler.

Troisièmement, la densité. 100 conteneurs Docker avec des images de développement pèsent facilement plusieurs gigaoctets de mémoire. 100 forks forkd pèsent ~26 Mo (100 × 265 Ko). L'article d'Emir's Blog "Your Container Is Not a Sandbox" fait un tour complet de cet argument : l'écosystème VVM partagé en Rust permet des optimisations que l'écosystème OCI (Docker/containerd) ne permet pas par conception.

La tendance agent VM — forkd n'est pas un cas isolé

forkd n'est pas le seul projet dans cet espace. Il s'inscrit dans un mouvement plus large que le guide de manveerc sur Substack qualifie de "agent VM era" — le passage du conteneur à la micro-VM comme unité de calcul pour les agents IA.

Multikernel avec son projet Sandlock pousse encore plus loin : 1000 sandboxes en 718 ms avec un CoW fork au niveau processus comme API first-class. Leur approche est complémentaire : là où forkd fork au niveau VM KVM, Sandlock fork au niveau processus avec une isolation renforcée.

rust-nano-vm adopte une autre stratégie : un binaire unique en Rust avec un cold start de ~12 ms et ~0,5 MiB par fork. Plus lent que forkd sur le fork, mais plus simple à déployer puisqu'il n'y a pas de dépendance à Firecracker.

La liste awesome-agent-sandbox recense d'ailleurs des dizaines de solutions dans cette catégorie : micro-VMs, conteneurs avec isolation renforcée (gVisor), harness d'isolation spécialisés. Le point commun : toutes visent le même problème que forkd résout avec une élégance particulière.

Ce qui distingue forkd dans ce paysage, c'est la combinaison du mapping MAP_PRIVATE (zéro copie de pages) avec Firecracker (isolation KVM éprouvée) dans un binaire Rust auto-suffisant. C'est le bon compromis au bon moment.

Cas d'usage concrets — quand forkd change la donne

Les flottes d'agents de code en parallèle

Quand un outil comme Orca, l'IDE qui pilote une flotte d'agents en parallèle lance 10 agents sur 10 fichiers différents, chaque agent a besoin de son environnement isolé. Avec forkd, on prépare un snapshot avec le codebase, on fork 10 enfants en ~8 ms, et chaque agent travaille dans sa VM dédiée. Si un agent fait n'importe quoi (boucle infinie, suppression de fichiers), les autres ne sont pas impactés.

La délégation de sous-agents

L'architecture de délégation de tâches avec sous-agents dans Hermes Agent #14 suppose que chaque sous-agent s'exécute dans un environnement isolé mais cohérent avec celui du parent. forkd fournit exactement cela : un sous-agent est un fork du snapshot parent, avec le même filesystem et le même état, mais incapable d'affecter les autres sous-agents.

Les pipelines CI/CD pilotés par agents

Un agent muni de GPT-5.3 Codex (OpenAI) — score agentic de 80 sur le benchmark de référence — génère un patch, le teste dans un fork, observe le résultat, itère. Chaque itération coûte moins d'une milliseconde de temps de setup. Un pipeline qui prenait 5 minutes passe à 30 secondes, dont la quasi-totalité est le temps d'exécution réel des tests.

Intégration avec les LLM agentic — quel modèle piloté dans un fork ?

La performance du sandboxing n'a pas d'importance si le modèle qui pilote l'agent est incapable de produire du code correct. La combinaison forkd + bon LLM est ce qui rend l'architecture viable en production.

Pour les agents qui itèrent intensément (boucle edit-test-fix), un modèle rapide comme Claude Sonnet 4.6 (Anthropic, score 81.4) est un bon compromis vitesse/qualité. Chaque itération est rapide, le coût par tour est modéré, et la qualité de code est suffisante pour la majorité des tâches.

Pour les tâches de raisonnement plus complexes où le nombre d'itérations est faible mais chaque itération doit être pertinente, GPT-5.5 (OpenAI, score 98.2) ou Gemini 3 Pro Deep Think (Google, score 95.4) sont plus adaptés. On fork moins souvent, mais chaque fork exécute un code de meilleure qualité.

Pour le self-host complet — le combo ultimate — Kimi K2.6 Moonshot AI (score 88.1, self-host) ou GLM-5 Reasoning de Z.AI (score 82, self-host) permettent de garder tout en local : le LLM, le runtime d'agent, et les sandboxes forkd. C'est l'architecture que visent les équipes qui veulent un agent IA open source avec Ollama en local.

Le point clé : forkd est agnostique au modèle. Il sandboxe l'exécution, pas le raisonnement. Mais la qualité du modèle détermine le nombre de forks nécessaires, et donc le bénéfice réel de la vitesse de forkd.

Performance détaillée — les chiffres qui comptent

Les données publiées par le projet et la communauté permettent de construire un tableau comparatif clair.

Source : données compilées depuis GitHub/deeplethe/forkd, Reddit r/SideProject, northflank, et rust-nano-vm.

Le chiffre le plus significatif est le ratio mémoire. 265 Ko par instance signifie qu'un serveur avec 8 Go de RAM peut théoriquement héberger ~30 000 sandboxes simultanées. En pratique, avec l'overhead KVM et les pages modifiées, on parle plutôt de 5 000 à 10 000. C'est néanmoins un ordre de grandeur au-dessus des conteneurs.

Limites et compromis techniques — forkd n'est pas magique

L'isolation KVM a un coût en CPU. Chaque VM forkée a son propre vCPU virtuel, même si le scheduler Linux gère cela efficacement. Pour des workloads où l'agent exécute du code CPU-intensive (compilation, calcul), le surcoût par rapport à un processus natif est mesurable — typiquement 5 à 15 % selon le benchmark.

Le filesystem en CoW a aussi ses limites. Les écritures sont isolées par instance, mais la lecture reste partagée via le snapshot. Si un agent modifie massivement le filesystem (npm install complet, compilation de dépendances), les pages CoW se multiplient et la consommation mémoire explose. forkd est optimisé pour les workloads où le fork est court et les modifications sont ciblées — exactement le pattern d'un agent de code qui édite un fichier puis lance un test.

Le réseau est un autre point d'attention. Firecracker supporte le networking via TAP devices, mais configurer le networking pour 100 VMs forkées en parallèle demande une infrastructure réseau spécifique. La plupart des déploiements de forkd pour agents de code utilisent un networking minimal (localhost only) ou pas de networking du tout, ce qui est suffisant pour les tests unitaires mais pas pour les intégrations qui appellent des APIs externes.

Enfin, forkd est un projet jeune. L'écosystème autour de créer un agent IA est mature, mais l'intégration de forkd dans les frameworks existants demande du travail de glue code. Ce n'est pas un produit SaaS avec une API REST et un dashboard — c'est un runtime qu'il faut intégrer soi-même.

forkd vs les plateformes de sandboxing propriétaires

Le post de Threads/@simplifyinai décrit forkd comme un "e2b killer". C'est une comparaison méritée sur le plan technique, mais les deux ne ciblent pas exactement le même public.

e2b (et les plateformes similaires comme Modal, E2B, Daytona) offrent un service managé : pas besoin de gérer l'infrastructure KVM, le networking, le garbage collection des VMs. On appelle une API, on obtient un sandbox. Le prix est la perte de contrôle et le coût récurrent.

forkd est self-hosted. Vous contrôlez l'infrastructure, vous payez le serveur (un VPS chez Hostinger à quelques euros par mois suffit pour des tests), et vous n'avez pas de limite d'appels API. En contrepartie, vous gérez vous-même la sécurité de l'hyperviseur, le monitoring, et la résilience.

Pour les équipes qui veulent comprendre comment choisir les meilleurs LLM pour les agents IA, la logique est la même : soit vous payez pour la commodité (API propriétaire), soit vous self-hostez pour le contrôle (forkd + modèle local). forkd s'inscrit résolument dans la deuxième catégorie.

Comment forkd s'intègre dans une stack agent complète

Une stack agent moderne avec forkd ressemble à ça :

1. Orchestrateur : un framework d'agent qui décompose la tâche, décide quand forker, et collecte les résultats. Les meilleurs agents IA autonomes intègrent ce pattern d'orchestration.
2. LLM : le modèle qui génère le code et les commandes à exécuter dans chaque fork. Hébergé en API ou en local.
3. forkd : le runtime de sandboxing qui fork les micro-VMs, isole l'exécution, et renvoie les résultats (stdout, stderr, fichiers modifiés).
4. Snapshot manager : la couche qui gère les snapshots initiaux, les met à jour (par exemple après un npm install réussi qu'on veut rendre disponible pour tous les forks suivants), et nettoie les enfants terminés.

Le point d'intégration clé est l'interface entre l'orchestrateur et forkd. L'orchestrateur doit savoir quand fork (avant une exécution risquée), quand branch (pour sauvegarder un état intermédiaire coûteux à reconstruire), et quand détruire les enfants (dès que le résultat est collecté).

C'est là que le framework Agent Skills devient pertinent : en standardisant les workflows des agents de codage, il crée des points d'insertion naturels pour des primitives comme fork() et branch(). Un workflow "test variant" devient un appel fork() + exécution + collecte + destroy.

❌ Erreurs courantes

Erreur 1 : Confondre fork de VM et fork de processus

forkd ne fait pas un fork() Unix classique. Il clone une machine virtuelle KVM complète avec son propre espace d'adressage virtuel. L'isolation est au niveau matériel, pas au niveau processus. Utiliser forkd comme si c'était un simple multiprocesseur est une erreur qui mène à des architectures inutilement complexes pour des tâches qui n'ont pas besoin d'isolation KVM.

Erreur 2 : Forker depuis un snapshot trop gros

Si le snapshot initial contient tout un environnement de développement avec Node.js, Python, des centaines de packages et des gigaoctets de données, le bénéfice du CoW s'effondre. Le temps de fork reste faible (~0,8 ms), mais dès que les enfants commencent à toucher des pages différentes, la mémoire explose. La bonne pratique : des snapshots minimaux, augmentés progressivement via branch().

Erreur 3 : Ignorer le coût du premier snapshot

forkd est ultra-rapide pour fork depuis un snapshot existant. Mais créer ce snapshot initial prend du temps : démarrer la VM, installer les dépendances, sérialiser l'état. Si votre workflow fork un snapshot différent à chaque appel (au lieu de réutiliser le même), vous perdez tout le bénéfice. Le pattern correct est "créer une fois, fork N fois".

Erreur 4 : Négliger le nettoyage des enfants

Un fork consomme 265 Ko au minimum, mais ce chiffre monte dès que l'enfant écrit. Des centaines de forks non détruits peuvent saturer la RAM sans que vous le remarquiez immédiatement. Un garbage collector simple (timeout ou compteur de forks actifs) est indispensable en production.

❓ Questions fréquentes

forkd remplace-t-il Docker pour le déploiement d'agents ?

Non. forkd est spécialisé dans le fork rapide de micro-VMs pour des exécutions courtes et isolées. Docker reste adapté pour le déploiement de services longue durée. Les deux peuvent coexister : Docker pour l'infrastructure, forkd pour les sandboxes d'agents.

Peut-on utiliser forkd avec un LLM en local ?

Oui. forkd est agnostique au LLM. Vous pouvez le combiner avec un modèle self-hosté comme Kimi K2.6 ou GLM-5 via Ollama pour une stack 100 % locale. L'agent appelle le LLM en local, puis envoie les commandes générées à forkd pour exécution isolée.

Quelle est la différence avec e2b ?

e2b est un service managé de sandboxes avec API REST, facturé à l'usage. forkd est un runtime open-source self-hosté basé sur Firecracker avec du fork CoW. forkd est plus rapide sur le fork (~0,8 ms vs ~100 ms pour un nouveau sandbox e2b) mais demande de gérer l'infrastructure soi-même.

Est-ce que branch() est sûr pour des données sensibles ?

branch() snapshotte l'état complet de la VM en vol, y compris la mémoire. Si le snapshot contient des secrets (clés API, tokens), ils sont présents dans le fichier de snapshot. Il faut chiffrer les snapshots ou s'assurer qu'aucun secret n'est chargé en mémoire avant le branch.

Combien de forks peut-on faire en parallèle ?

Théoriquement, la limite est la RAM disponible (265 Ko par fork au minimum) et le nombre de vCPUs que le scheduler Linux peut gérer. En pratique, les benchmarks montrent 100 forks en ~100 ms. Au-delà de quelques milliers, l'overhead KVM devient le facteur limitant.

✅ Conclusion

forkd résout un problème précis que l'industrie de l'agent IA commençait à peine à identifier formellement : le besoin d'un sandboxing aussi rapide qu'un fork processus mais aussi sûr qu'une VM. En utilisant le copy-on-write du noyau Linux appliqué à des micro-VMs KVM, le projet atteint un point d'équilibre qui change les mathématiques du déploiement d'agents de code. Si vous construisez des agents IA autonomes qui exécutent du code en boucle, forkd mérite une place dans votre stack.