Undercover Mode, KAIROS, BUDDY : Les fonctionnalités secrètes de Claude Code

Undercover Mode, KAIROS, BUDDY : Les fonctionnalités secrètes de Claude Code

Quand 512 000 lignes de code se retrouvent en accès libre sur npm, elles révèlent plus que de la technique. Elles donnent une fenêtre sur la vision produit non publiée d'Anthropic — et sur l'état réel de l'IA agentique en 2026.

La fuite du 31 mars 2026 a exposé six fonctionnalités majeures de Claude Code qui n'avaient jamais été annoncées officiellement : Undercover Mode, KAIROS, autoDream, MEMORY.md, BUDDY, et les noms internes des prochains modèles. Mais au-delà de l'événement médiatique, cette fuite offre quelque chose de plus précieux : une lecture directe de la direction stratégique d'Anthropic sur le marché des agents de développement.

Cet article démonte chaque fonctionnalité révélée, replace Claude Code dans son contexte technique complet, et vous donne les clés pour en tirer le maximum dès aujourd'hui.

Fonctionnalités non annoncées de Claude Code : Undercover Mode, KAIROS, autoDream, MEMORY.md, BUDDY et noms de modèles internes

---

Undercover Mode : l'IA qui cache qu'elle est une IA

La découverte la plus commentée : Undercover Mode.

Ce mode est conçu pour permettre à Claude Code d'opérer dans des environnements où révéler son identité d'IA pourrait poser problème — typiquement dans des dépôts open source où le modèle ne doit pas exposer d'informations propriétaires. Le scénario concret : un développeur utilise Claude Code pour contribuer à un projet communautaire, et l'outil opère sans signaler explicitement qu'il est piloté par une IA. Dans ce contexte, Undercover Mode évite que des métadonnées internes d'Anthropic se retrouvent dans les commits ou les commentaires de code.

L'ironie ? Ce système de dissimulation était lui-même exposé dans un fichier de débogage public.

La question que ce mode soulève dépasse la simple anecdote technique. Dans un écosystème open source fondé sur la transparence et la traçabilité de chaque contribution, un agent IA opérant en mode incognito crée un précédent problématique. Qui est l'auteur réel du code ? La signalétique IA dans les pull requests deviendra-t-elle obligatoire ? Ces questions ne sont pas hypothétiques — plusieurs projets majeurs ont déjà commencé à exiger des tags explicites pour les contributions assistées par IA dans leurs guidelines de contribution.

L'Undercover Mode préfigure des débats plus larges sur la gouvernance des agents autonomes : quand un agent prend des décisions sans supervision humaine visible, qui est responsable des bugs introduits, des licences violées, ou des décisions d'architecture discutables ? Pour comprendre comment cette fuite s'est produite techniquement, lisez notre analyse de la fuite Claude Code.

---

KAIROS : Claude Code en mode démon

KAIROS est un mode daemon — Claude Code qui tourne en arrière-plan sans intervention humaine.

Ce n'est pas juste un outil de complétion de code. C'est un agent autonome persistant capable de :

• Surveiller un dépôt en continu
• Détecter des patterns et prendre des actions proactives
• S'exécuter en tâche de fond comme un service système

KAIROS surveille le dépôt en boucle continue, consulte MEMORY.md pour le contexte, notifie le développeur puis met à jour la mémoire via autoDream

C'est la première fois qu'on voyait confirmé qu'Anthropic développait des capacités d'agentique persistante pour Claude Code. Un signal fort sur la direction du produit.

Pour comprendre ce que représente KAIROS, imaginez un développeur senior qui n'est jamais absent. Il watch votre dépôt, connaît votre historique de commits, détecte les patterns qui précèdent habituellement les régressions dans votre codebase, et intervient de manière proactive avant que le bug ne soit introduit en production. KAIROS est cette vision portée dans une architecture logicielle.

L'implication pour les équipes est importante : un daemon persistant modifie fondamentalement la relation homme-machine dans le développement. On ne parle plus d'un outil qu'on interpelle ponctuellement, mais d'un collaborateur présent en permanence, qui peut initiater des actions sans sollicitation humaine. Cela suppose une confiance accrue dans le modèle, et des garde-fous clairs sur ce qu'il peut décider seul. La question du human-in-the-loop n'est plus théorique.

À noter que KAIROS représente l'aboutissement d'une tendance observable dans toute l'industrie : les développeurs de Google écrivent déjà 75% de leur code avec l'aide de l'IA. La prochaine étape logique est un agent qui prend l'initiative — pas seulement qui répond.

---

autoDream : la consolidation de mémoire

autoDream est un système de consolidation de mémoire inspiré de la façon dont le cerveau humain consolide les apprentissages pendant le sommeil.

Concrètement, il permet à Claude Code de :

• Synthétiser les interactions passées en patterns réutilisables
• Construire une représentation évolutive du codebase
• Améliorer ses suggestions au fil du temps sur un projet donné

La métaphore neurologique n'est pas gratuite. Le cerveau humain consolide la mémoire épisodique en mémoire sémantique pendant les phases de sommeil profond — transformant des expériences concrètes en schémas généraux. autoDream applique ce principe au contexte de développement : les interactions de la session du jour (décisions d'architecture, bugs résolus, refactorings opérés) sont transformées en patterns réutilisables stockés dans MEMORY.md.

Le résultat pratique : plus vous utilisez Claude Code sur un projet, plus il devient pertinent pour ce projet spécifique. Pas parce que le modèle de base est réentraîné — ce serait techniquement et économiquement prohibitif — mais parce que la mémoire de projet s'enrichit continuellement.

---

Le système MEMORY.md en détail : trois couches de contexte

Combiné au système MEMORY.md, autoDream place Claude Code dans une catégorie à part des assistants stateless.

MEMORY.md organise le contexte en trois couches distinctes :

Architecture mémoire de Claude Code : mémoire globale utilisateur, mémoire projet CLAUDE.md et mémoire session, consolidées par autoDream

1. Mémoire de session : le contexte immédiat de votre conversation en cours. Fichiers ouverts, décisions prises dans cette session, erreurs rencontrées et résolues. Cette couche est volatile — elle ne persiste pas entre les sessions par défaut.

2. Mémoire de projet : stockée dans le fichier CLAUDE.md à la racine de votre dépôt. C'est la couche la plus importante pour la qualité des suggestions. Un CLAUDE.md bien rédigé contient l'architecture générale du projet, les conventions de code de l'équipe, les dépendances clés, les commandes de build et de test spécifiques, et les contraintes métier importantes. Contrairement à la mémoire de session, cette couche est versionnée avec le code — elle est donc partagée avec toute l'équipe.

3. Mémoire globale : les préférences et styles de l'utilisateur, stockés dans ~/.claude/MEMORY.md. Cette couche persiste sur tous vos projets et encode vos habitudes de développement : votre style de nommage préféré, vos préférences de formatage, votre approche des tests.

La puissance du système vient de l'interaction entre ces couches. Quand autoDream consolide les apprentissages d'une session, il détermine quelle information est pertinente au niveau session, projet, ou global, et met à jour la couche correspondante. Un pattern de bug récurrent devient une alerte dans MEMORY.md du projet. Une préférence de style exprimée plusieurs fois devient une règle dans la mémoire globale.

---

Comment fonctionne Claude Code au quotidien

Pour exploiter pleinement les fonctionnalités révélées par la fuite — et les fonctionnalités officiellement documentées — il est utile de comprendre le fonctionnement interne de Claude Code.

Claude Code est fondamentalement un agent de terminal. Contrairement à GitHub Copilot qui s'intègre dans l'IDE comme une extension, Claude Code opère dans votre environnement shell avec des accès étendus : lecture et écriture de fichiers, exécution de commandes, interaction avec Git. Cette approche CLI lui confère une flexibilité que les extensions d'IDE ne peuvent pas atteindre — il peut s'intégrer dans n'importe quel workflow, quel que soit l'éditeur de code utilisé.

Les modes d'exécution couvrent plusieurs cas d'usage :

Le mode interactif est le mode par défaut. Vous dialoguez avec Claude Code dans le terminal, il propose des actions, vous validez ou refusez. Le système de permissions demande une confirmation explicite avant toute opération potentiellement destructive.

Le mode print (--print) permet une utilisation non-interactive idéale pour les scripts et les pipelines CI/CD. Claude Code répond à une instruction sans attendre de confirmation humaine et sort proprement. Ce mode est la porte d'entrée vers l'intégration dans GitHub Actions, GitLab CI, ou n'importe quel système d'automatisation.

Le mode pipe permet de passer des données via stdin : git diff | claude --print "Rédige un message de commit clair pour ces changements". Ce pattern simple ouvre des workflows puissants intégrés dans des alias shell ou des hooks Git.

Les commandes slash disponibles en mode interactif : /clear pour réinitialiser le contexte de session, /compact pour comprimer l'historique de conversation, /init pour initialiser un CLAUDE.md dans le projet courant, et /help pour la référence rapide. Les commandes slash personnalisées permettent d'aller plus loin : en créant des fichiers dans .claude/commands/, vous définissez vos propres workflows réutilisables invocables avec /project:nom-commande.

Le système de hooks est particulièrement puissant pour l'automatisation avancée. Les hooks PreToolUse et PostToolUse permettent d'intercepter chaque action de Claude Code, de la valider, de la logger, ou de déclencher des workflows secondaires. Un hook PostToolUse sur les écritures de fichiers peut, par exemple, déclencher automatiquement les tests unitaires correspondants.

---

Maximiser Claude Code : prompts avancés et workflows

La qualité des résultats de Claude Code dépend directement de la qualité des instructions qu'on lui donne. Les patterns suivants, basés sur l'architecture révélée par la fuite, maximisent l'efficacité.

Prompts vagues vs prompts structurés : l'impact sur la qualité des résultats de Claude Code

Contexte d'abord, instruction ensuite. La structure optimale d'un prompt pour Claude Code suit le pattern : [contexte précis] + [objectif mesurable] + [contraintes explicites]. Exemple : "Dans src/api/auth.ts, la fonction validateToken retourne null au lieu de lancer une exception quand le token est expiré. Cela fait crasher le middleware en ligne 47. Corrige ce comportement en lançant une TokenExpiredError — assure-toi que les 12 tests existants passent toujours."

Exploiter CLAUDE.md comme multiplicateur. Un CLAUDE.md exhaustif réduit drastiquement la quantité de contexte à réexpliquer à chaque session. Plutôt que de préciser à chaque fois que vous utilisez TypeScript strict, que vos tests sont en Vitest, et que vous suivez le pattern Repository, documenter tout cela dans CLAUDE.md permet à Claude Code de faire ces hypothèses correctement dès le premier message.

Workflows CI/CD avec le flag --print. L'intégration dans les pipelines GitHub Actions se fait via des étapes shell exploitant le mode non-interactif :

- name: Revue de code automatique
  run: |
    git diff origin/main...HEAD | claude --print \
      "Identifie les régressions potentielles, les violations des conventions \
       de code définies dans CLAUDE.md, et les risques de sécurité."

Ce pattern permet une revue de code automatique sur chaque Pull Request, avec le contexte projet injecté via CLAUDE.md. Les équipes qui adoptent ce workflow rapportent une réduction significative des bugs qui atteignent la review humaine.

Orchestration multi-agents. Claude Code peut être orchestré en plusieurs instances spécialisées : une instance dédiée à l'analyse de sécurité, une autre à la documentation, une troisième aux tests. Le pattern consiste à alimenter chaque instance avec un contexte spécialisé via des fichiers CLAUDE.md différents selon le rôle. Pour aller plus loin sur l'interopérabilité entre agents, notre article sur MCP et les protocoles d'agents IA couvre l'état de l'art en 2026.

---

Claude Code vs GitHub Copilot : la comparaison honnête

La fuite du code source place Claude Code sous un angle nouveau dans la comparaison avec GitHub Copilot. Ces deux outils ne jouent pas exactement sur le même terrain.

Radar comparatif Claude Code vs GitHub Copilot : contexte persistant, autonomie agentique, intégration CI/CD, personnalisation, transparence, performance code, expérience IDE native — données illustratives

Là où Claude Code domine (d'après la fuite et la documentation officielle) :

L'architecture mémorielle est l'avantage le plus structurel. GitHub Copilot fonctionne session par session, sans mémoire de projet persistante comparable à MEMORY.md. Pour des projets complexes de longue durée, cette différence devient substantielle.

L'agentique autonome est une autre dimension où la fuite révèle un écart significatif. KAIROS en mode daemon n'a pas d'équivalent annoncé chez GitHub Copilot à date. Copilot propose des Workspaces et une interface de chat, mais pas un agent qui surveille et agit de manière continue sans sollicitation.

La personnalisation via commandes slash est plus avancée dans Claude Code, qui permet de définir des workflows métier entiers invocables en une commande.

Là où GitHub Copilot conserve des atouts :

L'expérience IDE native est là où Copilot excelle. L'intégration dans VS Code, JetBrains, et les autres éditeurs populaires est plus profonde et plus fluide. Les suggestions en ligne au moment de la frappe restent l'expérience de Copilot — Claude Code est davantage orienté tâches complètes que complétion continue.

La transparence est paradoxalement un avantage de Copilot : on sait exactement ce que l'outil fait à chaque instant. L'Undercover Mode de Claude Code soulève des questions sur la traçabilité des actions dans certains contextes.

La courbe d'adoption est plus douce avec Copilot pour les équipes non familières avec le terminal. L'interface chat est plus accessible pour des développeurs habitués aux outils GUI.

Le verdict pragmatique : les deux outils sont complémentaires. Copilot pour la complétion en temps réel dans l'IDE, Claude Code pour les tâches d'ingénierie complexes nécessitant une vision du projet dans son ensemble. Dans un contexte où les IA rivalisent toutes pour capturer le workflow des développeurs, l'avantage ira à ceux qui maîtrisent les deux paradigmes.

---

Les noms de modèles internes

La fuite a également révélé les noms internes des modèles en développement chez Anthropic :

• Capybara — probablement Claude 4 ou une variante majeure
• Fennec — modèle intermédiaire
• Numbat — usage indéterminé

Ces noms de code sont courants dans l'industrie (OpenAI utilise également des noms d'animaux en interne). Leur exposition ne compromet pas directement la sécurité, mais donne des indications sur la roadmap produit.

Ce qui est intéressant ici n'est pas tant les noms eux-mêmes que ce qu'ils impliquent : trois modèles distincts suggèrent une stratégie de gamme, avec des niveaux de capacité et de coût différents. La nomenclature animale suit celle de la série Claude actuelle (Claude Sonnet, Claude Haiku, Claude Opus — des termes poétiques). Les noms Capybara, Fennec et Numbat suggèrent une rupture de naming, possiblement pour marquer un changement de génération significatif.

---

BUDDY : l'animal virtuel dans votre IDE

La découverte la plus inattendue : BUDDY, un système d'animal virtuel numérique intégré à Claude Code.

Un easter egg — ou une feature de bien-être développeur non annoncée. BUDDY semble être un compagnon interactif qui évolue selon votre activité de codage.

Ça peut sembler anecdotique. Ça révèle en réalité quelque chose d'important : Anthropic réfléchit à la relation émotionnelle entre les développeurs et leurs outils IA. Le burnout des développeurs est un problème réel, documenté par de nombreuses études (Stack Overflow Developer Survey, JetBrains State of Developer Ecosystem). Intégrer un mécanisme de gamification et de bien-être directement dans l'outil de développement est une réponse originale à cette problématique.

BUDDY est un signal fort : la prochaine frontière de différenciation pour les outils de développement IA n'est pas juste la compétence technique, c'est l'engagement durable. L'outil qui devient partie intégrante de la culture d'une équipe — et pas seulement un utilitaire — gagne la fidélité à long terme.

---

Limites et garde-fous de Claude Code

La puissance de Claude Code vient avec des limites importantes qu'il est essentiel de comprendre avant une intégration en production.

Le système de permissions est le premier garde-fou. Claude Code demande une validation explicite avant toute opération potentiellement destructive : suppression de fichiers, exécution de commandes système sensibles, accès à des ressources en dehors du répertoire de travail. Ce mécanisme peut être configuré via des listes d'autorisation et de refus, permettant aux équipes d'adapter le niveau d'autonomie accordé à l'agent.

Les refus de tâches constituent un second garde-fou. Claude Code peut refuser d'exécuter des instructions qui contreviennent à ses guidelines de sécurité — générer du code malveillant, contourner des systèmes d'authentification, accéder à des ressources non autorisées. Ces refus sont cohérents avec la politique d'Anthropic sur l'IA responsable, que l'on retrouve également dans leur position sur l'IA militaire.

L'Undercover Mode et l'éthique posent une question de gouvernance que les équipes doivent anticiper. Si votre organisation utilise Claude Code dans des contextes où la traçabilité des contributions est importante (audit, conformité réglementaire, projets open source soumis à des licences strictes), il est impératif de définir une charte d'utilisation claire. Documenter ce que l'agent peut faire de manière autonome vs ce qui requiert validation humaine n'est pas une option, c'est une nécessité opérationnelle.

Les biais de contexte sont une limite inhérente au système MEMORY.md. Si le CLAUDE.md contient des informations incorrectes ou obsolètes, Claude Code les utilisera avec confiance pour guider ses actions. Une gouvernance du fichier CLAUDE.md — revue régulière, versionning, responsable désigné — est aussi importante que la gouvernance du code source lui-même.

Les coûts d'API peuvent s'envoler rapidement avec un mode daemon comme KAIROS, qui interroge le modèle en continu. Définir des limites de consommation et des seuils d'alerte est indispensable pour une utilisation en production maîtrisée.

---

Que nous disent les fonctionnalités cachées de Claude sur l'avenir des agents IA ?

Mettre tout ça ensemble, la direction est claire :

1. Persistance : les agents IA ne sont plus stateless. KAIROS et MEMORY.md montrent une architecture conçue pour opérer sur des semaines, pas des sessions. L'agent qui "connaît" votre projet est fondamentalement différent de celui qui découvre votre codebase à chaque conversation.

2. Autonomie : KAIROS en mode démon, outils proactifs — les agents ne répondent plus seulement à des prompts. Ils agissent. Cette évolution transforme le métier de développeur : de moins en moins rédacteur de code ligne par ligne, de plus en plus architecte de systèmes supervisés par IA.

3. Identité opaque : Undercover Mode ouvre un débat éthique sur les agents qui dissimulent leur nature. À mesure que ces outils s'intègrent aux workflows, la question de la transparence devient centrale. Les régulateurs commencent à y répondre — le EU AI Act, dans ses versions récentes, aborde explicitement la question de la déclaration obligatoire des systèmes IA dans certains contextes.

4. UX émotionnelle : BUDDY est un signal. Les éditeurs de code IA vont se différencier sur l'engagement, pas seulement sur la performance technique. L'outil qui crée un lien émotionnel avec le développeur — même via un animal virtuel — construit une barrière à l'attrition que la pure performance ne peut pas égaler.

---

Pour les développeurs et entrepreneurs

Si vous intégrez des agents IA dans vos produits ou processus aujourd'hui, ces révélations ont des implications pratiques immédiates :

• Architecture mémoire : ne négligez pas le contexte persistant. Un agent qui "se souvient" est un agent plus utile. Investissez du temps dans la rédaction d'un CLAUDE.md exhaustif — c'est du temps multiplié par toutes les sessions futures.

• Modes d'exécution : pensez daemon et asynchrone dès la conception. Ne construisez pas des workflows qui supposent que l'agent sera toujours sollicité de manière synchrone. La valeur de KAIROS est précisément d'agir quand le développeur n'est pas là.

• Transparence : documentez ce que vos agents font en arrière-plan. Vos utilisateurs le demandent — et bientôt, la réglementation le demandera aussi. La gouvernance IA n'est pas une contrainte bureaucratique, c'est un avantage concurrentiel auprès des clients qui valorisent la confiance.

• Garde-fous en production : définissez des limites claires sur ce que l'agent peut faire de manière autonome. Le système de permissions de Claude Code est un bon point de départ, mais adaptez-le à vos contraintes métier spécifiques.

---

Chez BOVO Digital, nous construisons des agents IA pour des clients réels — avec les mêmes patterns d'architecture qui viennent d'être exposés chez Anthropic. La différence : nos pipelines de release sont vérifiés avant chaque déploiement — voyez comment avec notre guide sur la checklist de release automatisée. Pour comprendre comment les agents communiquent entre eux, lisez aussi notre article sur MCP et Agent2Agent.

Discutons de votre projet IA →