Code Mode dans Claude Code : écrire du JS pour enchaîner les appels d'outils, de 150 000 à 2 000 tokens
🔎 Anthropic change la façon dont ses agents appellent leurs outils
Le 17 novembre 2026, Anthropic a déployé la version 2.1.323 de Claude Code avec une nouveauté discrète mais potentiellement structurante : le Code Mode. Une feature expérimentale, opt-in, qui change radicalement la mécanique interne de l'agent. Au lieu d'exécuter les appels d'outils MCP un par un via le function calling classique, Claude écrit du JavaScript qui enchaîne plusieurs appels en une seule étape.
L'idée vient directement d'un article de recherche d'Anthropic sur l'exécution de code avec MCP, publié en amont. Le chiffre qui résume tout : un workflow agentique qui consommait 150 000 tokens en approche classique tombe à 2 000 tokens avec l'approche « code-as-action ». Soit 98,7 % d'économie, en temps comme en coût.
Pourquoi maintenant ? Parce que les agents sont devenus des consommateurs de contexte insatiables. Chaque définition d'outil chargée dans le prompt, chaque résultat intermédiaire renvoyé au modèle, chaque étape de raisonnement entre deux appels : tout cela se facture en tokens et en latence. À l'échelle d'un agent qui tourne des centaines de fois par jour, la facture explose. Code Mode est la réponse d'Anthropic à ce problème — et un signal fort sur la direction que prend l'ingénierie agentique.
L'essentiel
- Code Mode est disponible dans Claude Code v2.1.323 (17 novembre 2026) comme feature expérimentale opt-in, activable via une variable d'environnement.
- Le principe : au lieu de charger toutes les définitions d'outils MCP dans le contexte et de renvoyer chaque résultat intermédiaire au modèle, Claude écrit du JavaScript qui appelle les outils et ne retourne que l'output final utile.
- Gain mesuré par Anthropic : de 150 000 tokens à 2 000 tokens sur un exemple de workflow MCP, soit 98,7 % d'économie de temps et de coût (source).
- Trois mécanismes clés : le code n'expose que les outils réellement nécessaires, les résultats intermédiaires restent dans le scope du script (pas dans le contexte du modèle), et les étapes de contrôle (boucles, conditions) sont exécutées par le runtime, pas par le LLM.
- Activation :
CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 claude— c'est explicitement expérimental, à ne pas mettre en production critique sans garde-fous.
Outils recommandés
| Outil | Usage principal | Prix (novembre 2026) | Idéal pour |
|---|---|---|---|
| Claude Code | Agent de code avec Code Mode expérimental | Inclus dans les abonnements Claude, vérifiez sur anthropic.com | Développeurs qui chaînent des outils MCP |
| Claude Opus 4.7 (Adaptive) | Raisonnement agentique complexe | Vérifiez sur anthropic.com | Workflows multi-étapes avec beaucoup d'outils |
| Claude Sonnet 4.6 | Agent rapide et économique | Vérifiez sur anthropic.com | Tâches agentiques à fort volume |
Pour choisir le modèle adapté à vos workflows agentiques, notre comparatif des meilleurs LLM pour coder détaille les compromis entre raisonnement, latence et coût. Et si vous explorez l'écosystème plus large, notre guide des meilleurs outils IA pour le code positionne Claude Code face à Cursor, Copilot et Cline.
Qu'est-ce que Code Mode, concrètement ?
Code Mode est un mode d'exécution de Claude Code où le modèle écrit du JavaScript pour appeler ses outils, plutôt que de les appeler un par un via le function calling standard. Claude Code exécute ce code dans la session, et seul le résultat utile remonte au modèle.
La feature a été ajoutée le 17 novembre 2026 dans la v2.1.323 comme fonctionnalité expérimentale opt-in, comme le rapporte Marktechpost. La documentation officielle sur code.claude.com précise le cadre : opt-in, expérimental, activé par variable d'environnement.
Dans la pratique, la différence est invisible pour l'utilisateur — Claude continue de répondre normalement. Mais sous le capot, la mécanique change du tout au tout :
- Function calling classique : le modèle voit toutes les définitions d'outils, émet un appel, attend le résultat dans son contexte, raisonne, émet l'appel suivant. Chaque étape consomme des tokens.
- Code Mode : le modèle écrit un script qui enchaîne les appels. Le runtime exécute le script. Les résultats intermédiaires transitent entre les outils sans jamais repasser par le contexte du modèle. Seul le résultat final remonte.
C'est une inversion de responsabilité : le LLM décide quoi faire, le code décide comment le faire efficacement.
Activation
Une variable d'environnement suffit :
CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 claude
Pas d'interface, pas de configuration complexe. C'est le marqueur classique d'une feature qu'Anthropic teste en conditions réelles avant de décider de la généraliser.
Le vrai problème : MCP coûte cher en tokens
Le Model Context Protocol résout un problème d'interopérabilité mais en crée un d'efficacité : plus vous connectez d'outils, plus votre contexte se remplit avant même la première question.
L'article de recherche d'Anthropic décompose le gaspillage en trois couches :
1. Les définitions d'outils. Chaque serveur MCP expose ses outils avec leurs schémas. Un agent connecté à dix serveurs peut embarquer des dizaines de milliers de tokens de définitions — chargés à chaque requête, même si un seul outil sera utilisé.
2. Les résultats intermédiaires. Un workflow typique enchaîne des appels : lister des fichiers, lire leur contenu, extraire des données, appeler une API. En approche classique, chaque résultat intermédiaire est renvoyé dans le contexte du modèle, même quand il ne sert qu'à préparer l'appel suivant. Un fichier de 10 000 tokens qui doit être filtré consomme 10 000 tokens avant le filtrage.
3. Le raisonnement entre les étapes. Entre deux appels d'outils, le modèle « parle » : il planifie, reformule, commente. Ce texte de transition est du bruit tokenique qui ne produit aucune valeur.
Le résultat est documenté chiffre à l'appui : 150 000 tokens pour un workflow qui en nécessite 2 000 avec l'approche code-as-action. Ce n'est pas une optimisation marginale, c'est un changement d'ordre de grandeur. À l'échelle d'une équipe qui fait tourner des agents en continu, c'est la différence entre une facture viable et une facture absurde.
Pourquoi l'approche « code-as-action » gagne
Le code-as-action déplace la logique de contrôle du modèle vers le runtime, et c'est ce déplacement qui produit les gains. Anthropic identifie trois mécanismes précis.
Le filtrage progressif des outils
Quand Claude écrit du code, il n'a besoin de voir que les outils qu'il utilise réellement. Le script agit comme un contrat explicite : si le workflow ne nécessite que trois outils sur les quarante disponibles, les trente-sept autres ne polluent pas le contexte. En function calling classique, le modèle porte tout le catalogue en permanence.
Les données restent dans le scope
C'est le point le plus élégant. Dans un script, le résultat d'un appel peut être stocké dans une variable, filtré, transformé, puis passé à l'appel suivant — sans jamais entrer dans le contexte du modèle. Le modèle a écrit la logique une fois ; le runtime l'exécute avec les vraies données. Seul l'output final, condensé et pertinent, remonte au LLM.
C'est exactement le mécanisme qui fait passer un workflow de 150 000 à 2 000 tokens : les 148 000 tokens économisés étaient du transit de données, pas du raisonnement.
Le contrôle de flux devient déterministe
Boucles, conditions, gestion d'erreurs : en function calling classique, chaque itération d'une boucle est une décision du modèle, avec son coût en tokens et son risque d'incohérence. En code-as-action, for et if sont exécutés par le runtime. Zéro token, zéro hallucination possible sur la logique de contrôle. Le modèle ne décide qu'une chose : la structure du script.
Cette trajectoire rejoint une tendance plus large de l'ingénierie agentique, que nous analysions déjà dans notre article sur la preprint MIT/Berkeley/Georgia Tech sur l'infrastructure évolutive et la latence des agents : la performance des agents se joue de plus en plus dans l'orchestration, pas seulement dans le modèle.
Ce que ça change en pratique pour les développeurs
Code Mode transforme la manière dont vous structurez vos workflows MCP — à condition d'accepter un changement de mentalité.
Les appels en parallèle deviennent naturels
En JavaScript, lancer trois appels indépendants en parallèle est trivial (Promise.all). En function calling classique, le modèle doit décider explicitement de paralléliser, et beaucoup d'implémentations séquentialisent par défaut. Pour un workflow qui lit plusieurs fichiers ou interroge plusieurs API, le gain de latence est immédiat.
Les résultats transitent entre appels
L'exemple type : récupérer des données d'une API, les filtrer, puis envoyer le résultat filtré à un second outil. En mode classique, chaque étape charge l'intégralité des données dans le contexte. En Code Mode, le filtrage se fait dans le script. Anthropic illustre ce pattern avec un cas concret : utiliser le code pour lever une limite de retry sur un appel d'outil — une logique de contrôle qui, en mode classique, aurait coûté des allers-retours complets entre le modèle et l'outil.
Le debugging change de nature
Quand quelque chose casse, vous ne debuggez plus une conversation avec un modèle mais un script JavaScript. C'est à la fois une bonne nouvelle (outils familiers, stack traces, exécution pas à pas) et un changement de posture : vous relisez du code généré par le modèle, avec tout ce que ça implique de vigilance.
Pour ceux qui découvrent l'écosystème agentique sans passer par le code, notre guide sur la création d'un chatbot IA sans écrire une ligne de code reste une porte d'entrée valable — mais Code Mode illustre précisément la frontière : au-delà d'un certain niveau de complexité, les approches no-code atteignent leurs limites, un sujet que nous traitons en profondeur dans notre comparatif no-code vs code.
Anthropic joue sur plusieurs tableaux à la fois
Code Mode ne sort pas de nulle part. C'est la déclinaison produit de la recherche d'Anthropic sur le code-as-action, et elle s'inscrit dans une stratégie agentique plus large. Quelques semaines plus tôt, Anthropic avait ouvert Claude Managed Agents en self-hosted, complétant sa stack agentique — orchestration managée d'un côté, exécution efficace des outils de l'autre.
La logique est cohérente : Anthropic construit une pile complète où le modèle (Claude Opus 4.7, Claude Sonnet 4.6), l'orchestration (Managed Agents) et l'exécution (Code Mode) sont optimisés ensemble. C'est un avantage compétitif difficile à répliquer pour des acteurs qui ne contrôlent qu'une couche.
La comparaison avec les autres approches code-first de tool calling, détaillée par Marktechpost, montre qu'Anthropic n'est pas seul sur cette piste — mais c'est le premier grand éditeur à l'intégrer directement dans son outil de développement grand public plutôt que dans un framework séparé.
Mon avis, sans détour : c'est la bonne direction. Le function calling classique a été un excellent échafaudage, mais il confond « le modèle décide » et « le modèle exécute ». Séparer les deux est la maturation naturelle du domaine.
Limites et précautions : ce que Code Mode ne résout pas
Code Mode est expérimental, et il faut le traiter comme tel.
La sécurité d'exécution de code généré
Faire exécuter du JavaScript par un agent, c'est lui donner un pouvoir d'exécution arbitraire. Anthropic exécute le code dans la session Claude Code, ce qui limite la surface par rapport à une exécution système complète — mais un agent qui écrit du code qui appelle des outils reste un agent avec des permissions. En environnement d'entreprise, la question du sandboxing et des permissions par outil doit être traitée sérieusement avant tout déploiement.
La lisibilité et l'audit
Un workflow en function calling classique laisse une trace conversationnelle lisible : chaque appel est visible, chaque résultat est dans l'historique. Un workflow en Code Mode compacte plusieurs appels dans un script. Pour l'audit et le debugging, c'est plus efficace — mais la traçabilité fine des appels individuels demande des outils dédiés.
Le coût de génération du code
Écrire un script coûte des tokens de sortie, généralement plus chers que les tokens d'entrée. Pour des workflows simples — deux appels séquentiels, pas de transformation de données — le function calling classique peut rester plus efficace. Code Mode brille sur les workflows complexes et répétitifs ; il n'apporte rien sur les trivialités.
Le statut expérimental
La documentation est claire : feature opt-in, expérimentale. L'API et le comportement peuvent évoluer. Ne bâtissez pas une pipeline de production critique dessus sans plan de repli vers le mode classique.
❌ Erreurs courantes
Erreur 1 : activer Code Mode partout par défaut
C'est une feature expérimentale opt-in pour une raison. L'activer systématiquement sur tous vos projets expose vos sessions à du code généré non testé, sans bénéfice sur les workflows simples.
La solution : activez-la sur les projets qui utilisent intensivement MCP — plusieurs serveurs, workflows multi-étapes, transformations de données. Mesurez la consommation de tokens avant/après sur un cas réel avant de généraliser.
Erreur 2 : croire que l'économie de tokens remplace l'optimisation des outils
Les 98,7 % d'économie viennent d'un exemple spécifique de workflow MCP lourd. Votre mileage variera — radicalement. Un workflow avec deux appels légers ne verra aucun gain ; un workflow qui transite des fichiers volumineux entre outils verra des gains massifs.
La solution : profilez vos workflows. Identifiez ceux où les résultats intermédiaires dominent la consommation de contexte — c'est là que Code Mode paie.
Erreur 3 : confondre « moins de tokens » et « moins de supervision »
Réduire le contexte de 150 000 à 2 000 tokens signifie aussi que vous voyez moins de ce que fait l'agent. Les résultats intermédiaires ne remontent plus. Si un outil renvoie une donnée corrompue au milieu du workflow, le script peut la propager sans que rien ne l'alerte.
La solution : ajoutez des validations explicites dans vos workflows critiques — vérifications de schéma, garde-fous sur les valeurs extrêmes — plutôt que de compter sur le modèle pour détecter l'anomalie au vol.
Erreur 4 : ignorer la version
Code Mode arrive avec la v2.1.323. Sur une version antérieure, la variable d'environnement ne fait rien — ou pire, un comportement différent selon votre installation.
La solution : vérifiez votre version de Claude Code avant de tester, et consultez les notes de version officielles pour les changements éventuels.
❓ Questions fréquentes
Code Mode est-il disponible pour tous les utilisateurs de Claude Code ?
Oui, mais en opt-in expérimental. Il faut être en version 2.1.323 (17 novembre 2026) ou ultérieure et activer la variable d'environnement CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 au lancement. Sans activation, Claude Code fonctionne en function calling classique, sans changement.
Faut-il savoir programmer en JavaScript pour utiliser Code Mode ?
Non pour l'usage de base : c'est Claude qui écrit le code, pas vous. Mais comprendre JavaScript vous aide à relire les scripts générés, à debugger quand ça casse et à ajouter des garde-fous. Plus votre workflow est critique, plus cette compétence compte.
L'économie de 98,7 % s'applique-t-elle à tous les workflows ?
Non. Le chiffre de 150 000 à 2 000 tokens provient d'un exemple précis documenté par Anthropic sur un workflow MCP lourd. Les gains dépendent du volume de données transitant entre les outils et du nombre d'étapes. Sur des workflows simples, le gain peut être nul voire négatif, car générer du code coûte des tokens de sortie.
Code Mode remplace-t-il le function calling classique ?
Pas encore. Les deux modes coexistent dans Claude Code, et Code Mode reste expérimental. La trajectoire suggérée par la recherche d'Anthropic indique que l'approche code-as-action deviendra probablement dominante pour les workflows complexes, mais le function calling garde l'avantage sur les appels simples et isolés.
Code Mode fonctionne-t-il avec n'importe quel serveur MCP ?
Oui, c'est l'intérêt : Code Mode s'applique aux outils MCP déjà connectés à votre session. Aucune modification des serveurs n'est nécessaire — c'est la couche d'appel qui change, pas les outils eux-mêmes. Vérifiez simplement la compatibilité dans la documentation officielle pour les cas particuliers.
Quelle différence avec les frameworks agentiques code-first existants ?
La différence est l'intégration. Les approches code-first existantes vivent dans des frameworks séparés que vous devez adopter. Code Mode est intégré nativement dans Claude Code, activé par une variable d'environnement, avec le runtime géré par l'outil. C'est moins flexible qu'un framework dédié, mais beaucoup plus accessible.
✅ Conclusion
Code Mode est la première déclinaison produit grand public de l'approche code-as-action d'Anthropic, et son chiffre fondateur — 150 000 tokens réduits à 2 000 — dit tout : l'avenir des agents ne se joue pas dans des modèles plus gros, mais dans des architectures qui gaspillent moins. Testez-le en opt-in sur vos workflows MCP les plus lourds, mesurez, et gardez le mode classique pour le reste. Pour aller plus loin sur le choix des modèles qui alimentent vos agents, consultez notre comparatif des meilleurs LLM pour coder.