Que fait exactement l'agent IA ? Analyse complète de la fuite de 500 000 lignes de code de Claude Code

51,2 mille lignes de code, 1 906 fichiers, 59,8 Mo de source map. Dans la nuit du 31 mars, Chaofan Shou de Solayer Labs a découvert que le produit phare d’Anthropic, Claude Code, exposait tout le code source complet dans un dépôt public npm. En quelques heures, le code a été répliqué sur GitHub et le nombre de forks a dépassé 41 000.

Ce n’est pas la première fois qu’Anthropic commet ce genre d’erreur. Lors de la première publication de Claude Code en février 2025, un même incident de fuite de source map s’était déjà produit. Cette fois, le numéro de version est v2.1.88, avec une cause identique : l’outil de build Bun génère par défaut des source maps, et le fichier a été oublié dans .npmignore.

La plupart des articles recensent les œufs de Pâques de la fuite, comme un système d’animaux virtuels, ou un « mode infiltration » qui permet à Claude d’envoyer anonymement du code à des projets open source. Mais le vrai sujet à disséquer est plutôt celui-ci : pourquoi un même modèle de Claude se comporte-t-il si différemment dans la version web et dans Claude Code ? Que fait exactement les 512 000 lignes de code ?

Le modèle n’est que l’écume

La réponse se cache dans la structure du code. D’après une analyse de rétro-ingénierie des sources divulguées par la communauté GitHub, sur 512 000 lignes de TypeScript, le code d’interface qui appelle directement le modèle IA ne représente qu’environ 8 000 lignes, soit 1,6 % du total.

Que fait donc les 98,4 % restants ? Les deux plus grands modules sont le moteur de requêtes (46 000 lignes) et le système d’outils (29 000 lignes). Le moteur de requêtes gère les appels à l’API LLM, la sortie en flux, l’orchestration du cache et la gestion des conversations multi-tours. Le système d’outils définit environ 40 outils intégrés et 50 commandes slash, formant une architecture de type plugin : chaque outil dispose de contrôles de permissions indépendants.

Il y a aussi 25 000 lignes pour le rendu de l’interface utilisateur terminal (dont un fichier appelé print.ts qui compte jusqu’à 5 594 lignes, avec une seule fonction dépassant 3 167 lignes), 20 000 lignes pour la sécurité et le contrôle des permissions (y compris 23 vérifications Bash numérotées pour la sécurité et 18 commandes internes Zsh masquées), et enfin 18 000 lignes pour un système d’orchestration multi-agents.

Le chercheur en machine learning Sebastian Raschka, après avoir analysé le code divulgué, indique que si Claude Code est plus fort que la version web du même modèle, ce n’est pas dû au modèle lui-même, mais à l’échafaudage logiciel construit autour du modèle : chargement du contexte du dépôt, orchestration d’outils dédiés, stratégies de cache et collaboration de sous-agents. Il estime même que si on applique la même architecture logicielle à d’autres modèles comme DeepSeek ou Kimi, on peut obtenir une amélioration des performances de programmation comparable.

Une comparaison intuitive aide à comprendre l’écart. Quand vous posez une question dans ChatGPT ou dans la version web de Claude, le modèle traite puis renvoie une réponse, et la conversation s’arrête sans rien laisser. Mais la démarche de Claude Code est totalement différente : au démarrage, il lit d’abord les fichiers de votre projet, comprend la structure de votre base de code, et mémorise vos préférences, par exemple « ne pas mock une base de données dans les tests ». Il peut exécuter des commandes directement dans votre terminal, éditer des fichiers et lancer des tests. Lorsqu’une tâche est complexe, il la découpe en plusieurs sous-tâches et les confie à différents sous-agents pour traitement en parallèle. En d’autres termes : l’IA de la version web est une fenêtre de questions-réponses, tandis que Claude Code est un collaborateur qui vit sur votre ordinateur.

Certains ont comparé cette architecture à un système d’exploitation : les 42 outils intégrés correspondent aux appels système, le système de permissions correspond à la gestion des utilisateurs, le protocole MCP correspond aux pilotes de périphériques, et l’orchestration des sous-agents correspond à la planification des processus. Lorsqu’un outil est livré, il est par défaut marqué comme « non sûr, inscriptible », sauf si le développeur déclare explicitement qu’il est sûr. L’outil d’édition de fichiers force aussi à vérifier si vous avez déjà lu ce fichier : si vous ne l’avez pas lu, vous ne pouvez pas le modifier. Ce n’est pas un simple chatbot auquel on a ajouté quelques outils : c’est un environnement d’exécution complet, centré sur LLM, avec des mécanismes de sécurité complets.

Cela signifie une chose : la barrière concurrentielle des produits IA ne se situe peut-être pas au niveau du modèle, mais au niveau de l’ingénierie.

À chaque brèche de cache, le coût est multiplié par 10

Dans le code divulgué, il y a un fichier nommé promptCacheBreakDetection.ts, qui suit 14 vecteurs possibles menant à l’invalidation du prompt cache. Pourquoi les ingénieurs d’Anthropic consacrent-ils autant d’efforts à empêcher la rupture de cache ?

Regardez simplement la tarification officielle d’Anthropic. Par exemple, pour Claude Opus 4.6, le prix d’entrée standard est de 5 dollars pour chaque million de tokens, mais en cas de succès du cache, le prix de lecture n’est que de 0,5 dollar, soit 90 % moins cher. À l’inverse, à chaque brèche de cache, le coût d’inférence est multiplié par 10.

Cela explique les nombreuses décisions d’architecture qui semblent « excessivement conçues » dans le code divulgué. Au démarrage, Claude Code charge la branche git courante, les enregistrements de commits récents et le fichier CLAUDE.md comme contexte ; ces contenus statiques sont mis en cache globalement, séparés du contenu dynamique par des marqueurs de frontière, pour garantir que chaque conversation n’ait pas à retraiter le contexte déjà existant. Le code contient aussi un mécanisme appelé sticky latches, qui empêche les changements de mode de casser les caches déjà établis. Les sous-agents sont conçus pour réutiliser le cache du processus parent, plutôt que de reconstruire leur propre fenêtre de contexte.

Il y a un détail qui mérite d’être développé. Les personnes qui ont utilisé des outils de programmation IA savent que plus la conversation est longue, plus les réponses de l’IA sont lentes : à chaque tour, il faut renvoyer à nouveau l’historique précédent au modèle. La pratique habituelle consiste à supprimer les anciens messages pour libérer de l’espace, mais le problème est que supprimer n’importe quel message casse la continuité du cache : tout l’historique doit alors être retraité, ce qui fait grimper à la fois le délai et les coûts.

Dans le code divulgué, il existe un mécanisme appelé cache_edits : au lieu de supprimer réellement les messages, il applique dans la couche API un marqueur « ignorer » aux anciens messages. Le modèle ne voit plus ces messages, mais la continuité du cache n’est pas brisée. Cela signifie qu’une longue conversation qui dure plusieurs heures, une fois nettoyée de quelques centaines de vieux messages, conserve une vitesse de réponse à peu près identique à celle du premier tour. Pour les utilisateurs ordinaires, c’est la réponse de fond à « pourquoi Claude Code peut prendre en charge des conversations infiniment longues sans ralentir ».

D’après les données de surveillance internes issues de la fuite (provenant des commentaires du code dans autoCompact.ts, avec la date annotée du 10 mars 2026), avant la mise en place d’une limite d’échec maximale pour la compression automatique, Claude Code gaspillait environ 250 000 appels API par jour. Il y a eu 1 279 sessions d’utilisateurs où des échecs de compression consécutifs ont dépassé 50 fois ; la pire session a échoué 3 272 fois d’affilée. Le correctif n’a consisté qu’à ajouter une ligne de restriction : MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES = 3.

Ainsi, pour un produit IA, le coût d’inférence du modèle n’est peut-être pas la couche la plus coûteuse ; ce sont plutôt les défaillances de gestion du cache.

44 interrupteurs, pointant tous dans la même direction

Le code divulgué dissimule 44 feature flags : des commutateurs de fonctionnalités déjà compilés, simplement non publiés au public. D’après l’analyse de la communauté, ces flags sont regroupés en cinq catégories par domaine fonctionnel, la plus dense étant celle des « agents autonomes » (12), pointant vers un système nommé KAIROS.

KAIROS est cité plus de 150 fois dans le code source. C’est un mode de démon de type arrière-plan, qui tourne en permanence. Claude Code n’est plus seulement un outil qui répond quand vous l’appelez volontairement : c’est un agent qui tourne toujours en tâche de fond, qui observe et enregistre en continu, puis agit de manière proactive au moment opportun. À condition de ne pas interrompre l’utilisateur : toute opération susceptible de bloquer l’utilisateur pendant plus de 15 secondes est retardée.

KAIROS intègre aussi une perception du focus du terminal. Le code contient un champ terminalFocus, qui détecte en temps réel si l’utilisateur est en train de regarder la fenêtre du terminal. Lorsque vous basculez vers le navigateur ou une autre application, l’agent vous considère comme « absent », passe en mode autonome, exécute les tâches de manière proactive et soumet directement du code sans attendre votre confirmation. Lorsque vous revenez au terminal, l’agent repasse immédiatement en mode collaboratif : il fait d’abord un compte rendu de ce qu’il vient de faire, puis sollicite votre avis. Le degré d’autonomie n’est pas fixe : il varie en temps réel avec votre attention. Cela résout un problème gênant de longue date des outils IA : une IA entièrement autonome ne met pas les gens en confiance, et une IA totalement passive est trop peu efficace. Le choix de KAIROS est de régler dynamiquement l’initiative de l’IA en fonction de l’attention de l’utilisateur : tant que vous le fixez du regard, elle reste sage ; quand vous vous éloignez, elle travaille d’elle-même.

Un autre sous-système de KAIROS s’appelle autoDream : après avoir accumulé 5 sessions, ou après un intervalle de 24 heures, l’agent lance en arrière-plan un processus « de réflexion » en quatre étapes. D’abord, il scanne les mémoires existantes pour comprendre ce qu’il sait actuellement. Ensuite, il extrait les nouvelles connaissances des journaux de conversation. Puis il fusionne connaissances nouvelles et anciennes : il corrige les contradictions et supprime les doublons. Enfin, il simplifie l’index en supprimant les entrées obsolètes. Cette conception s’inspire des théories en science cognitive sur la consolidation de la mémoire. Quand les humains dorment, ils organisent les souvenirs de la journée ; quand les utilisateurs quittent, KAIROS réorganise le contexte du projet. Pour un utilisateur ordinaire, cela signifie que plus vous utilisez Claude Code longtemps, plus sa compréhension de votre projet devient précise, et pas seulement « se souvenir de ce que vous avez dit ».

La deuxième grande catégorie est « anti-distillation et sécurité » (8 flags). Le point le plus notable est le mécanisme fake_tools : lorsque 4 conditions sont simultanément remplies (flag activé à la compilation, activation de l’entrée CLI, utilisation de l’API de première partie, et le commutateur distant de GrowthBook est à true), Claude Code injecte de fausses définitions d’outils dans la requête API. L’objectif est de polluer les jeux de données susceptibles d’être utilisés pour l’enregistrement du trafic API et pour entraîner des modèles concurrents. C’est une forme de défense nouvelle dans la course à l’armement de l’IA : ce n’est pas empêcher que vous copiiez, c’est faire en sorte que vous copiiez des choses erronées.

En plus, le code fait aussi apparaître un code modèle Capybara (divisé en trois niveaux : version standard, version fast et version à fenêtre de contexte d’un million), que la communauté soupçonne largement comme un code interne de la série Claude 5.

Œuf de Pâques : dans 512 000 lignes de code, une petite animal électronique

Entre toutes les architectures d’ingénierie sérieuses et les mécanismes de sécurité, les ingénieurs d’Anthropic ont quand même fabriqué en douce un système complet d’animaux virtuels, en interne codé BUDDY.

D’après le code divulgué et l’analyse de la communauté, BUDDY est un animal de terminal pseudo-mécanique (拟物化) qui apparaît sous forme de bulles ASCII à côté du champ de saisie de l’utilisateur. Il a 18 espèces (dont des capybaras, des salamandres, des champignons, des fantômes, des dragons, ainsi qu’une série d’espèces originales comme Pebblecrab, Dustbunny, Mossfrog) et elles sont classées en cinq niveaux selon la rareté : commun (60 %), rare (25 %), peu commun (10 %), épique (4 %) et légendaire (1 %). Chaque espèce a aussi une « variante brillante » : la plus rare, Shiny Legendary Nebulynx, n’apparaît qu’avec une probabilité d’un sur dix mille.

Chaque BUDDY a cinq attributs : DEBUGGING (débogage), PATIENCE (patience), CHAOS (chaos), WISDOM (sagesse) et SNARK (sarcasme piquant). Il peut aussi porter des chapeaux, avec des options comme une couronne, un haut-de-forme, un chapeau à hélice, un halo, un chapeau de sorcier, et même un mini canard. La valeur de hachage de l’ID utilisateur détermine quel animal vous fait éclore ; Claude génère pour lui un nom et une personnalité.

D’après le plan de mise en ligne de la fuite, BUDDY devait initialement commencer une phase de test du 1er avril au 7 avril, puis être lancé officiellement en mai, d’abord pour les employés internes d’Anthropic.

512 000 lignes de code, 98,4 % dédiées à de l’ingénierie hardcore, mais à la fin, quelqu’un a passé du temps à créer un petit animal électronique qui porte un chapeau à hélice. C’est peut-être la toute ligne de code la plus humaine de toute la fuite.