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

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

Ce n’est pas la première fois qu’Anthropic commet cette erreur. Lors de la première publication de Claude Code en février 2025, la même fuite de source map s’était déjà produite. Cette fois, la version est v2.1.88, la cause de la fuite est la même : l’outil de build Bun génère par défaut des source map, et le fichier .npmignore a omis ce fichier.

La plupart des articles se concentrent sur les œufs de Pâques contenus dans le bilan des fuites, comme un système de compagnie virtuelle, ou un « mode infiltré » qui permet à Claude de soumettre anonymement du code à des projets open source. Mais la vraie question, celle qui mérite d’être disséquée, est la suivante : pourquoi le même modèle Claude se comporte-t-il si différemment dans la version web et dans Claude Code ? Que fait exactement 512 000 lignes de code ?

Le modèle n’est que le sommet de l’iceberg

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 les 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 % de la totalité.

Alors, que font les 98,4 % restants ? Les deux plus gros 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 d’API LLM, la sortie en mode stream, l’orchestration du cache et la gestion de conversations à tours multiples. Le système d’outils définit environ 40 outils intégrés et 50 commandes slash, formant une architecture de type plug-in, avec un contrôle d’autorisations indépendant pour chaque outil.

En plus, il y a 25 000 lignes de code d’affichage pour l’UI du terminal (dont un fichier appelé print.ts qui fait jusqu’à 5 594 lignes, avec une seule fonction qui traverse 3 167 lignes), 20 000 lignes de contrôles de sécurité et d’autorisations (incluant 23 vérifications de sécurité Bash numérotées et 18 commandes internes Zsh masquées), ainsi qu’un système d’orchestration multi-agents de 18 000 lignes.

Le chercheur en apprentissage automatique Sebastian Raschka, après avoir analysé le code divulgué, indique que si Claude Code est plus fort que la version web avec le même modèle, ce n’est pas principalement à cause du modèle lui-même, mais de l’échafaudage logiciel construit autour du modèle : chargement du contexte du dépôt, planification d’outils dédiés, stratégies de cache et coopération de sous-agents. Il va même jusqu’à penser qu’en transposant la même architecture d’ingénierie à d’autres modèles comme DeepSeek ou Kimi, on pourrait aussi obtenir une amélioration des performances de programmation à peu près comparable.

Une comparaison intuitive aide à comprendre l’écart. Dans ChatGPT ou dans la version web de Claude, vous saisissez une question, le modèle traite et renvoie la réponse, puis la conversation s’arrête sans rien conserver. Mais la manière de faire 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 votre préférence selon laquelle « il ne faut pas mock une base de données dans les tests ». Il peut exécuter des commandes directement dans votre terminal, éditer des fichiers, lancer des tests, et lorsqu’il rencontre des tâches complexes, il les découpe en plusieurs sous-tâches qu’il assigne à différents sous-agents pour un traitement en parallèle. Autrement dit : 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.

Quelqu’un a comparé cette architecture à un système d’exploitation : les 42 outils intégrés correspondent à des appels système, le système d’autorisations correspond à la gestion des utilisateurs, le protocole MCP correspond aux pilotes d’appareils, et l’orchestration des sous-agents correspond à la planification des processus. À la livraison, chaque outil est par défaut marqué comme « non sûr, modifiable », sauf si le développeur déclare volontairement qu’il est sûr. L’outil qui édite des fichiers vérifie systématiquement si vous avez d’abord lu ce fichier ; sinon, il vous empêche de le modifier. Ce n’est pas qu’un chatbot discute avec quelques outils en plus : c’est un environnement d’exécution qui repose sur le LLM comme cœur, avec un mécanisme de sécurité complet.

Cela implique une chose : la barrière concurrentielle des produits IA ne se trouve peut-être pas dans la couche du modèle, mais dans la couche d’ingénierie.

Chaque fois que le cache est « percé », le coût est multiplié par 10

Dans le code divulgué, il existe un fichier appelé promptCacheBreakDetection.ts qui suit 14 types de vecteurs susceptibles de rendre le prompt cache invalide. Pourquoi les ingénieurs d’Anthropic consacrent-ils autant d’efforts à empêcher un « cache miss » ?

Regardez la tarification officielle d’Anthropic et vous comprendrez. Par exemple, pour Claude Opus 4.6, le prix standard pour l’entrée est de 5 dollars par million de tokens, mais si le cache est touché, le prix de lecture n’est que de 0,5 dollar, soit 90 % moins cher. À l’inverse, chaque fois qu’un cache est « percé », le coût de l’inférence est multiplié par 10.

Cela explique une grande partie des décisions d’architecture qui semblent, dans le code divulgué, relever d’un « sur-ingénierie ». Au démarrage, Claude Code charge la branche git courante, les derniers commits et le fichier CLAUDE.md comme contexte. Ces contenus statiques sont mis en cache globalement, séparés par des marqueurs de limites pour le contenu dynamique, afin de s’assurer que chaque conversation ne traite pas à nouveau un contexte déjà existant. Le code contient aussi un mécanisme appelé sticky latches, qui empêche que le changement de mode casse le cache déjà établi. Les sous-agents sont conçus pour réutiliser le cache du processus parent au lieu de reconstruire leur propre fenêtre de contexte.

Il y a un détail qui mérite d’être développé. Quiconque a utilisé des outils de programmation IA sait que plus la conversation est longue, plus la réponse de l’IA est lente, parce que chaque tour de conversation doit renvoyer à nouveau tout l’historique au modèle. La pratique habituelle consiste à supprimer les anciens messages pour libérer de l’espace. Mais supprimer n’importe quel message brise la continuité du cache, ce qui oblige à re-traiter l’historique complet de la conversation, faisant grimper à la fois la latence et les coûts.

Dans le code divulgué, il existe un mécanisme appelé cache_edits. Au lieu de ne vraiment supprimer les messages, il marque d’« ignorer » les anciens messages au niveau de l’API. Le modèle ne voit plus ces messages, mais la continuité du cache n’est pas rompue. Cela signifie qu’une longue conversation qui dure plusieurs heures, après le nettoyage de quelques centaines de messages anciens, conserve une vitesse de réponse presque identique à celle du premier tour. Pour les utilisateurs ordinaires, c’est la réponse sous-jacente à « pourquoi Claude Code peut supporter des conversations infiniment longues sans ralentir ».

D’après des données internes de supervision divulguées (issues des commentaires du code de autoCompact.ts, datés du 10 mars 2026), avant l’introduction d’une limite d’échec de compression automatique, Claude Code gaspillait environ 250 000 appels API par jour. Il y avait 1 279 sessions utilisateur qui ont connu 50 échecs de compression consécutifs ou plus ; la pire session en a eu 3 272 d’affilée. La correction consistait simplement à ajouter une ligne de limitation : MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES = 3.

Donc, pour les produits IA, le coût de l’inférence du modèle n’est peut-être pas la couche la plus chère ; c’est la défaillance de la gestion du cache qui l’est.

44 interrupteurs, tous pointent dans la même direction

Le code divulgué cache 44 feature flags — des interrupteurs de fonctionnalités déjà compilés, mais qui n’ont pas été publiés au public. D’après l’analyse de la communauté, ces flags sont regroupés en cinq catégories par domaine de fonction ; la plus dense est la catégorie « agents autonomes » (12), qui pointe vers un système nommé KAIROS.

KAIROS est cité dans le code source plus de 150 fois : c’est un mode de démon en arrière-plan, fonctionnant en permanence. Claude Code n’est plus seulement un outil qui répond quand vous l’appelez activement ; c’est un agent qui tourne toujours en arrière-plan, observe en continu, consigne, et agit de façon proactive au moment opportun. La condition est de ne pas interrompre l’utilisateur : toute opération susceptible de bloquer l’utilisateur plus de 15 secondes est retardée.

KAIROS intègre aussi une détection de focus du terminal. Le code comporte 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 passez au navigateur ou à d’autres applications, l’agent vous juge « absent » et bascule en mode autonome : il exécute les tâches de lui-même, soumet directement du code, sans vous demander de confirmation. Quand 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 fluctue en temps réel selon votre attention. Cela résout un problème gênant que les outils IA ont de longue date : une IA totalement autonome met les gens mal à l’aise, et une IA totalement passive est trop inefficace. Le choix de KAIROS est donc d’ajuster dynamiquement l’initiative de l’IA selon l’attention de l’utilisateur : vous la regardez, elle se tient tranquille ; vous vous éloignez, et elle se met à travailler toute seule.

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 a actuellement. Ensuite, il extrait les nouvelles connaissances des logs de conversation. Puis il fusionne les connaissances nouvelles et anciennes, corrige les contradictions et supprime les doublons. Enfin, il simplifie l’index et supprime les entrées obsolètes. Cette conception s’inspire de la théorie de la consolidation de la mémoire en sciences cognitives : pendant le sommeil, les humains réorganisent leurs souvenirs de la journée ; KAIROS, lui, réorganise le contexte du projet lorsque l’utilisateur s’éloigne. Pour les utilisateurs ordinaires, cela signifie que plus vous utilisez Claude Code longtemps, plus sa compréhension de votre projet est précise, et pas seulement « mémoriser ce que vous avez dit ».

La deuxième grande catégorie est « antidistillation et sécurité » (8 flags). Le plus notable est le mécanisme fake_tools : lorsque quatre conditions sont simultanément remplies (flag activé à la compilation, entrée CLI activée, utilisation d’une API first-party, et l’interrupteur distant GrowthBook réglé sur true), Claude Code injecte des définitions d’outils factices dans les requêtes API, afin de polluer des données de type jeu de données susceptibles d’être enregistrées dans le trafic API et utilisées pour entraîner les modèles des concurrents. Il s’agit d’une nouvelle forme de défense dans la course à l’armement IA : ce n’est pas vous empêcher de copier, c’est faire en sorte que ce que vous copiez soit faux.

Par ailleurs, le code fait aussi apparaître un code de modèle Capybara (réparti en trois niveaux : version standard, version fast, et version de fenêtre de contexte d’un million), et la communauté le devine largement comme le code interne de la série Claude 5.

Œuf de Pâques : une compagnie électronique se cache dans 512 000 lignes de code

Entre toutes les architectures d’ingénierie sérieuses et les mécanismes de sécurité, les ingénieurs d’Anthropic ont aussi discrètement construit tout un système de compagnon virtuel, codé en interne BUDDY.

D’après les fuites du code et l’analyse de la communauté, BUDDY est un animal de compagnie terminal à effet « pseudo-réaliste » ; il apparaît sous forme de bulles ASCII à côté de la zone de saisie utilisateur. Il a 18 espèces (dont un wombat d’eau, un triton, un champignon, un fantôme, un dragon, ainsi qu’une série de créatures originales comme Pebblecrab, Dustbunny, Mossfrog). Elles sont réparties en cinq niveaux de rareté : commun (60 %), rare (25 %), peu commun (10 %), épique (4 %) et légendaire (1 %). Chaque espèce possède aussi une « variante brillante » ; la plus rare, Shiny Legendary Nebulynx, n’apparaît qu’avec une probabilité sur 10 000.

Chaque BUDDY a cinq attributs : DEBUGGING (débogage), PATIENCE (patience), CHAOS (chaos), WISDOM (sagesse) et SNARK (mordant). Ils peuvent aussi porter des chapeaux, avec des options comme une couronne, un chapeau melon, 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 quelle créature vous allez faire éclore, et Claude lui génère un nom et une personnalité.

Selon le plan de lancement divulgué, BUDDY devait entrer en bêta du 1er au 7 avril, puis être officiellement lancé en mai, d’abord auprès des employés internes d’Anthropic.

512 000 lignes de code, 98,4 % pour du dur génie logiciel, mais à la fin quelqu’un prend le temps de faire un petit saurien électronique qui porte un chapeau à hélice. C’est peut-être la ligne de code la plus humaine de toute la fuite.