La fuite qui a changé la conversation
Le 31 mars 2026, des développeurs ont signalé que Claude Code v2.1.88 était livré avec une source map JavaScript de 59,8 Mo via le package npm, exposant la structure interne de la CLI de l'agent de codage d'Anthropic. Les rapports publics et la documentation du projet autour de cet incident décrivaient le package exposé comme contenant environ 512 000 lignes de TypeScript réparties sur environ 1 900 fichiers source, ce qui a immédiatement transformé une erreur d'emballage en document de conception pour la communauté de développeurs au sens large.
C'est la partie que la plupart des gens manquent. La vraie histoire n'a jamais été seulement que du code a fuité ; c'était que la fuite a rendu le harnais lisible. Une fois que les développeurs ont pu voir les pièces mobiles, il est devenu évident que l'innovation durable n'était pas "un LLM dans un terminal", mais la couche d'orchestration qui transforme un modèle en opérateur.
Ce qu'est réellement Claude Code sous le capot
Anthropic décrit Claude Code comme un outil de codage agentique qui vit dans le terminal, comprend votre codebase et aide en exécutant des tâches routinières, en expliquant le code et en gérant les workflows git via des commandes en langage naturel. En d'autres termes, Claude Code n'est pas seulement de l'autocomplétion avec une interface plus agréable ; c'est un runtime qui peut inspecter des fichiers, décider d'actions, appeler des outils, exécuter des commandes et continuer à itérer jusqu'à ce qu'une tâche soit terminée.
Cette distinction compte parce que l'expérience utilisateur est émergente. Le modèle génère du raisonnement et des instructions, mais le harnais décide quel contexte est chargé, quels outils sont autorisés, comment les sorties sont renvoyées, quand une permission est requise, comment la mémoire persiste et comment l'agent récupère d'un échec. C'est la machinerie que les utilisateurs ressentent réellement.
Pourquoi Claw-Code a explosé
Claw Code se présente comme une réécriture open source propre de l'architecture de harnais de Claude Code, construite à partir de zéro en Python et Rust plutôt que comme un fork direct de la codebase propriétaire d'Anthropic. La page du projet encadre explicitement cela comme "architecture, réimaginée", et les matériaux associés du dépôt notent que le développement a continué via des canaux maintenus par la communauté pendant les changements de propriété du dépôt.
Cet encadrement est la raison pour laquelle le projet a explosé comme un moment culturel. Claw-Code n'était pas intéressant seulement parce qu'il reflétait un produit célèbre ; il était intéressant parce qu'il transformait une catégorie auparavant opaque en quelque chose d'inspectable, modifiable et portable. Le moment où un harnais peut être réimplémenté en open source, l'exclusivité du vendeur commence à ressembler moins à un fossé et plus à un avantage d'emballage temporaire.
L'ingénierie de harnais expliquée
L'ingénierie de harnais est la discipline consistant à connecter l'intelligence du modèle à une action fiable. Elle se situe entre le LLM brut et le monde réel, et son travail est de rendre l'agent utile sans le rendre dangereux, fragile ou impossible à déboguer.
En termes pratiques, le harnais répond à des questions comme celles-ci :
- Quelles instructions sont assemblées avant qu'un tour ne commence ?
- Quelle mémoire est chargée, compactée ou rejetée ?
- Quels outils existent, et quel schéma exposent-ils ?
- Quand l'agent a-t-il besoin d'une approbation explicite de l'utilisateur ?
- Comment les sous-processus sont-ils isolés ?
- Comment les réponses en streaming sont-elles rendues dans le terminal ?
- Comment fonctionnent les commandes slash, les sessions et le changement de fournisseur ?
Les descriptions publiques de l'architecture de Claw Code pointent directement sur ces couches : gestion des commandes, plugins d'outils, abstraction de modèle, un moteur de requête, gestion des tâches, persistance des sessions, permissions, intégration MCP et un runtime Rust pour les chemins d'exécution critiques en termes de performance.
C'est pourquoi le terme "harnais" compte tant. Le harnais est ce qui transforme un modèle de frontière en un système avec posture, politique et répétabilité.
L'architecture de base
Claw Code décrit une conception divisée dans laquelle Python gère l'orchestration et Rust gère le travail critique en termes de performance du runtime. L'aperçu de l'architecture publié nomme les modules côté Python tels que commands.py, tools.py, models.py, query_engine.py, task.py et main.py, tandis qu'un noyau Rust gère le chemin de runtime de bas niveau.
Cette division n'est pas stylistique ; elle est opérationnelle.
| Couche | Rôle principal | Pourquoi il appartient là |
|---|---|---|
| Orchestration Python | Registre de commandes, assemblage de prompts, routage de modèle, logique de session, cycle de vie des tâches. | Python est rapide à faire évoluer, facile à inspecter et bien adapté au flux de contrôle d'agent. |
| Runtime Rust | Exécution sensible aux performances, comportement d'exécution des outils, streaming, permissions, plomberie de protocole. | Rust donne un contrôle plus strict sur la latence, l'isolation, la concurrence et la sécurité. |
Une façon propre de penser à cela est : Python décide ce qui devrait se passer ensuite, et Rust s'assure que cela se passe en toute sécurité, de manière cohérente et rapide. C'est l'essence d'un harnais d'agent de qualité production.
Séquence de démarrage
L'architecture devient beaucoup plus claire si vous suivez une seule tâche de l'entrée à la sortie.
- L'utilisateur entre une commande dans le terminal.
- La couche de session charge les instructions, l'état précédent du transcript et le contexte pertinent.
- La couche de prompt assemble le tour actuel pour le modèle.
- Le moteur de requête envoie la requête, gère le streaming et suit le budget ou les tentatives.
- Le modèle retourne soit une réponse directe, soit une action prévue.
- Le planificateur route cette action via le système d'outils.
- La couche de permission décide si l'action est autorisée, refusée ou nécessite une confirmation.
- Le runtime exécute l'outil dans un contexte isolé et renvoie les observations en streaming.
- L'agent consomme ces observations, met à jour la mémoire et termine soit la tâche, soit itère à nouveau.
Cette boucle est le produit. Le modèle est à l'intérieur de la boucle, mais la boucle elle-même est le véritable atout logiciel.
Voyez-le en FlowZap Code
Le diagramme suivant est un rendu conceptuel du workflow de harnais Claw-Code basé sur l'aperçu de l'architecture publié du projet. Il correspond au workflow au niveau de la conception des systèmes, capture la bonne boucle de contrôle et les bonnes frontières de couche, mais ne correspond pas exactement au niveau de l'implémentation.
User { # User
n1: circle label="Start"
n2: rectangle label="Enter CLI command"
n3: rectangle label="View streamed output"
n4: circle label="Done"
n1.handle(right) -> n2.handle(left)
n2.handle(bottom) -> Python.n5.handle(top) [label="Command"]
n3.handle(right) -> n4.handle(left)
}
Python { # Python Orchestration
n5: rectangle label="Load session context"
n6: rectangle label="Build prompt"
n7: rectangle label="Call model"
n8: diamond label="Tool needed?"
n9: rectangle label="Route tool call"
n10: rectangle label="Update memory"
n11: rectangle label="Finalize response"
n5.handle(right) -> n6.handle(left)
n6.handle(right) -> n7.handle(left)
n7.handle(bottom) -> External.n15.handle(top) [label="LLM request"]
n8.handle(bottom) -> n9.handle(top) [label="Yes"]
n8.handle(right) -> n11.handle(left) [label="No"]
n9.handle(bottom) -> Rust.n12.handle(top) [label="Tool call"]
n10.handle(right) -> n11.handle(left)
n11.handle(top) -> User.n3.handle(bottom) [label="Answer"]
}
Rust { # Rust Runtime
n12: diamond label="Permission granted?"
n13: rectangle label="Execute tool in sandbox"
n14: rectangle label="Stream tool events"
n12.handle(right) -> n13.handle(left) [label="Yes"]
n12.handle(top) -> Python.n11.handle(bottom) [label="Denied"]
n13.handle(bottom) -> External.n16.handle(top) [label="File access"]
n13.handle(right) -> n14.handle(left)
n13.handle(top) -> External.n17.handle(bottom) [label="MCP call"]
n14.handle(top) -> Python.n10.handle(bottom) [label="Observations"]
n14.handle(left) -> User.n3.handle(right) [label="Stream"]
}
External { # External Systems
n15: rectangle label="LLM provider"
n16: rectangle label="File system"
n17: rectangle label="MCP server"
n15.handle(left) -> Python.n8.handle(right) [label="Plan"]
n16.handle(left) -> Rust.n14.handle(right) [label="File data"]
n17.handle(left) -> Rust.n14.handle(bottom) [label="Tool data"]
}
La couche Python
Selon l'aperçu de l'architecture publique, l'espace de travail Python est où vit le comportement d'agent de haut niveau : enregistrement de commandes, définitions d'outils, abstraction de modèle, orchestration de requêtes et gestion des tâches. C'est la couche qui donne au système sa flexibilité, parce que c'est là que les prompts, les politiques, les règles de session et la sémantique de workflow peuvent changer rapidement sans reconstruire le runtime de bas niveau.
Vous pouvez penser à la couche Python comme cinq sous-systèmes coopérants :
- Registre de commandes : Mappe les commandes slash et les entrées de terminal à des comportements structurés.
- Abstraction de modèle : Permet à l'agent de cibler différents fournisseurs derrière une interface commune.
- Moteur de requête : Gère la construction de requête, le streaming, les tentatives et le contrôle au niveau du tour.
- Gestionnaire de tâches : Suit le cycle de vie, l'itération et quand une tâche devrait s'arrêter ou continuer.
- Gestionnaire de mémoire/session : Préserve le contexte à travers les tours et compacte les transcripts quand nécessaire.
C'est aussi la couche où la transparence open source devient puissante. Quand les développeurs peuvent inspecter directement la logique d'orchestration, ils peuvent échanger des fournisseurs, modifier des prompts, changer les permissions par défaut, réécrire le routage d'outils ou construire des commandes personnalisées sans attendre une roadmap de vendeur.
La couche Rust
Les matériaux publics de Claw Code décrivent un noyau Rust pour les chemins de runtime critiques en termes de performance, incluant le streaming, la gestion de protocole et les préoccupations d'exécution d'outils. Les mêmes matériaux mentionnent aussi un espace de travail Rust multi-crate et un chemin de migration actif vers un runtime plus entièrement natif.
Pourquoi est-ce important ? Parce qu'une fois qu'un agent peut réellement faire des choses sur votre machine, la qualité du runtime devient non-négociable.
La couche Rust est où les préoccupations systèmes ont tendance à atterrir :
- Application des permissions : Bloquer les actions dangereuses avant qu'elles ne se produisent.
- Runtime d'exécution : Exécuter des actions shell ou d'outils avec des garanties opérationnelles plus strictes.
- Streaming : Pousser la sortie de tokens et d'événements dans le terminal sans lag ou corruption d'état.
- Adaptateurs de protocole : Supporter des intégrations externes telles que les transports MCP et le comportement de client API.
- Sécurité et fiabilité : Réduire le code glue sujet aux plantages dans le chemin d'exécution le plus chaud.
Si Python est le "tronc cérébral" de l'orchestration, Rust est le squelette et le système nerveux en dessous.
Le système d'outils
L'un des signaux architecturaux les plus clairs dans la description publique du projet est l'accent sur un système d'outils basé sur des plugins avec des capacités protégées par des permissions. Le site de Claw Code décrit 19 outils intégrés et traite chaque capacité—telle que les E/S de fichiers, l'exécution shell, les opérations git, l'accès web ou le spawn d'agent—comme un outil autonome avec des contrôles explicites.
C'est important parce qu'un bon outillage d'agent n'est pas "donner à bash au modèle et prier." Un harnais mature fait des outils des objets de première classe avec :
- Un schéma.
- Un nom et un but.
- Une sémantique de permission.
- Des frontières d'exécution.
- Une sortie observable.
- Une gestion des erreurs.
- Des données de retour claires pour la prochaine étape de raisonnement.
C'est l'une des raisons pour lesquelles la couche de harnais est si importante. Plus le système d'outils devient structuré, moins l'agent ressemble à de l'autocomplétion et plus il ressemble à un environnement d'exploitation.
Gating des permissions
Le système de permission n'est pas seulement une fonctionnalité UX ; c'est un modèle de sécurité. Les matériaux publics de Claw Code mettent en avant des outils protégés par des permissions et un moteur de politique avec plusieurs modes de permission, des listes de refus et des prompts interactifs.
Cela vous dit beaucoup sur ce que les constructeurs d'agents sérieux optimisent. L'architecture la plus sûre n'est pas celle où le modèle "sait mieux" ; c'est celle où le modèle est structurellement empêché de contourner la politique. En d'autres termes, le LLM peut proposer des actions, mais le harnais reste l'autorité finale.
Cette conception a plusieurs avantages :
- Elle garde la politique en dehors du modèle.
- Elle rend le comportement plus vérifiable.
- Elle réduit la confiance dans l'obéissance aux prompts.
- Elle crée des points de contrôle propres pour l'approbation humaine.
- Elle réduit le rayon d'explosion des appels d'outils hallucinés ou surconfiants.
C'est l'une des leçons les plus profondes de tout le moment Claw-Code : ne comptez pas sur le modèle pour se policer lui-même.
Moteur de requête et boucle de tour
La page du projet Claw Code décrit le moteur de requête comme l'intelligence centrale du système, responsable des appels LLM, du streaming de réponse, de la mise en cache, de l'orchestration, des limites de tour et des contrôles de budget. Cela en fait le contrôleur de trafic du harnais, parce qu'il se situe entre l'assemblage de prompt, l'invocation de modèle et l'itération pilotée par outils.
Beaucoup de comportements de produit que les utilisateurs perçoivent comme "le modèle qui est intelligent" vivent souvent ici à la place :
- Combien de contexte est envoyé.
- Quand le transcript précédent est compacté.
- Comment les tentatives se produisent.
- Quand le système arrête de boucler.
- Comment les budgets sont appliqués.
- Comment la sortie en streaming est exposée à l'utilisateur.
C'est pourquoi deux outils utilisant le même modèle sous-jacent peuvent se sentir radicalement différents. Le moteur de requête façonne le tempo, la discipline et le coût.
Mémoire et sessions
Les matériaux publics de Claw Code soulignent aussi la persistance de session, la compaction de transcript et la mémoire multi-couche. C'est important parce que la mémoire dans les systèmes d'agents n'est pas une seule chose ; c'est habituellement plusieurs couches avec des durées de vie et des buts différents.
Une façon utile de l'encadrer est :
- Mémoire de tour : Ce que le modèle voit en ce moment.
- Mémoire de session : Ce qui persiste à travers le workflow actuel.
- Mémoire compacte : Une version résumée de l'interaction précédente utilisée pour économiser des tokens.
- Contexte découvert : Fichiers, docs ou code extraits parce que la tâche actuelle en a besoin.
Une fois que vous voyez la mémoire de cette façon, le harnais devient plus facile à raisonner. Les bons produits d'agent ne sont pas seulement "long context" ; ce sont des systèmes de contexte sélectifs.
Orchestration multi-agent
Les matériaux du projet Claw Code décrivent le support pour le spawn de sous-agents, ou "essaims," pour paralléliser du travail complexe dans des contextes isolés avec des patterns d'accès mémoire partagé. Cela pointe vers un modèle de harnais plus avancé dans lequel une boucle parent peut déléguer la recherche, les éditions de code, la validation ou l'analyse à des travailleurs subordonnés avant de fusionner les résultats.
C'est une avancée architecturale majeure par rapport à l'appel d'outils à thread unique. Une fois que vous introduisez des sous-agents, vous avez besoin de :
- Isolation.
- Agrégation de résultats.
- Contexte partagé mais limité.
- Contention de défaillance.
- Logique de supervision pour quand spawner, attendre, réessayer ou abandonner.
C'est pourquoi les systèmes multi-agents vivent ou meurent par la qualité du harnais. La logique d'orchestration devient exponentiellement plus importante à mesure que la concurrence augmente.
MCP et systèmes externes
Le site public de Claw Code met en avant le support MCP complet avec plusieurs types de transport incluant stdio, SSE, HTTP, WebSocket, SDK et modes d'accès par proxy. C'est important parce que MCP transforme le harnais en une couche de connecteur, pas seulement un wrapper CLI local.
Une fois que MCP est natif, l'agent n'est plus limité aux opérations shell et fichiers locales. Il peut se brancher sur des serveurs d'outils externes, des systèmes de données, des plateformes internes et des adaptateurs spécifiques à des services via un protocole standard. C'est pourquoi les gens décrivent de plus en plus MCP comme une couche de portabilité pour les écosystèmes d'agents : cela donne au harnais un moyen stable d'atteindre le monde extérieur.
Commandes slash et surface UX
Les matériaux de Claw Code mettent aussi en avant un système de commandes slash avec des commandes pour des choses comme le contrôle de session, la sélection de modèle, les permissions, le suivi des coûts, la compaction et l'export. C'est important parce que l'UX d'agent n'est pas seulement du chat ; c'est une grammaire de commande.
Les commandes slash font bien trois choses :
- Elles exposent des fonctionnalités puissantes sans gonfler la boucle d'interaction principale.
- Elles rendent l'état de session inspectable et contrôlable.
- Elles réduisent l'ambiguïté en transformant les méta-actions en commandes d'opérateur explicites.
En d'autres termes, les commandes slash font aussi partie du harnais. Ce sont la surface de contrôle humaine sur le moteur d'orchestration.
Pourquoi la combinaison Python et Rust est si forte
Le pattern Python-plus-Rust fonctionne parce qu'il correspond proprement aux deux problèmes les plus difficiles dans l'outillage d'agent : l'expérimentation et l'application. Python est idéal où vous voulez une itération rapide sur les prompts, la logique de routage, les politiques de tâches et les abstractions de fournisseurs. Rust est idéal où vous voulez un runtime plus serré autour de l'exécution, le streaming, les permissions et la correction de protocole.
Cette division aide aussi les équipes à évoluer à des vitesses différentes. La couche d'orchestration peut continuer à changer à mesure que le produit apprend, tandis que la couche de runtime peut durcir autour des garanties de performance et de sécurité. Pour les systèmes d'agents, c'est souvent un meilleur compromis que de forcer chaque préoccupation dans un seul langage.
Ce que Claw-Code a révélé
La vraie contribution de Claw-Code n'est pas seulement "de l'outillage open source à la Claude." C'est la démonstration publique que le harnais lui-même est maintenant un domaine compétitif. L'architecture que les gens avaient l'habitude de rejeter comme code glue se transforme en la couche de produit réelle.
Ce changement transforme le marché d'au moins quatre façons :
- Les modèles deviennent interchangeables. Les matériaux de projet publics mettent l'accent sur une conception agnostique des fournisseurs plutôt qu'un verrouillage mono-vendeur.
- Les permissions deviennent des fonctionnalités produit. Le gating d'outils et les moteurs de politique passent du détail d'implémentation au critère d'achat.
- La conception de mémoire devient une UX différenciante. La persistance de session, la compaction et la découverte de contexte affectent directement la qualité et le coût.
- Le support de protocole devient stratégique. Le support MCP natif transforme un agent d'assistant terminal en nœud d'écosystème.
C'est pourquoi ce moment semble plus grand qu'une fuite ou une réécriture. Cela a clarifié où se trouve réellement le levier.
Conclusions actionnables
Si vous construisez de l'outillage d'agent :
- Séparez l'orchestration de l'exécution.
- Faites du système d'outils un système centré sur le schéma.
- Mettez la politique sous le modèle, pas dedans.
- Traitez le moteur de requête comme une surface de produit.
- Conceptionnez la mémoire comme une infrastructure à couches, pas comme "juste plus de contexte."
- Ajoutez MCP tôt si les intégrations externes comptent.
- Faites des commandes slash partie de l'expérience opérateur.
Si vous évaluez de l'outillage d'agent :
- Demandez si la couche d'outils est protégée par des permissions.
- Demandez si les sessions peuvent persister et se compacter proprement.
- Demandez si le choix de fournisseur est abstrait ou verrouillé.
- Demandez si les systèmes externes se connectent via MCP ou des adaptateurs ad hoc.
- Demandez si le chemin de runtime est assez robuste pour une exécution réelle plutôt qu'une automatisation de niveau démo.
La leçon durable est simple : le harnais devient le système d'exploitation du travail IA. Claw-Code a rendu cela évident.