« Code execution with MCP » allège le contexte et accélère les workflows

Les agents IA basés sur le Model Context Protocol (MCP) peinent à scaler en raison d’une surcharge massive de la fenêtre de contexte. Anthropic propose une solution innovante en intégrant l’exécution de code au cœur du protocole, transformant les appels d’outils en scripts TypeScript exécutés dans un environnement sandboxed. Cette approche code-first réduit drastiquement la consommation de tokens et accélère les workflows complexes.

À retenir

• Le MCP classique souffre d’un « context bloat » qui gonfle les tokens et augmente latence et coûts.
• Approche code-first d’Anthropic : le modèle génère du code TypeScript pour composer des modules d’outils.
• Réduction de tokens : 98,7 % dans un workflow typique, de 150 000 à 2 000 tokens.
• Avantages : découverte progressive des outils, gestion de données volumineuses et préservation de la confidentialité.
• Similitude avec le « Code Mode » de Cloudflare pour les Workers.
• Compromis : complexité accrue et latence pour opérations simples.

Dans un paysage où les agents IA, ces entités autonomes entraînées à raisonner et agir via des LLM comme Claude, deviennent essentiels pour l’automatisation des entreprises, la scalabilité pose un défi majeur. Le protocole MCP, conçu pour intégrer des outils externes au contexte du modèle, atteint rapidement ses limites avec des données volumineuses, rendant les applications à grande échelle coûteuses et lentes. L’innovation d’Anthropic, baptisée « Code Execution with MCP », émerge comme une réponse opportune, particulièrement pour les ingénieurs et développeurs cherchant à déployer des workflows fiables sans explosion budgétaire. Publiée récemment, cette méthode repositionne l’IA non plus comme un simple orchestreur d’appels, mais comme un programmeur habile, exploitant la force des LLM en génération de code pour contourner les goulots d’étranglement contextuels. Son importance réside dans la démocratisation de l’automatisation avancée, accessible aux non-spécialistes via des abstractions simplifiées, tout en préservant l’efficacité pour les cas complexes.

Les limites du MCP classique face à la scalabilité des agents

Imaginez un agent IA chargé de transférer une transcription de réunion de Google Drive vers Salesforce : ce qui semble anodin vire au cauchemar technique avec le MCP traditionnel.

Le « context bloat » et ses conséquences sur coûts et latence

Dans le MCP standard, chaque définition d’outil – schémas, métadonnées – s’injecte dans la fenêtre de contexte du LLM. Cela provoque un « context bloat », une surcharge qui multiplie les tokens consommés. Pour une tâche comme l’extraction d’une longue transcription, le payload complet transite deux fois par le modèle : retour intermédiaire, puis réinjection pour l’outil suivant.

Résultat : des dizaines de milliers de tokens inutiles alourdissent la logique métier. La latence grimpe, les coûts explosent, et la fenêtre de contexte sature vite. Les agents, censés fluidifier les processus, deviennent impraticables pour des flux réels, comme l’analyse de documents volumineux ou l’intégration multi-systèmes.

Le double transit des données et les limites des outils

Le double transit force le modèle à traiter des données intermédiaires non essentielles à sa décision. Par exemple, une transcription de plusieurs pages passe intégralement par le LLM, même si seul un résumé compte. Cela non seulement dilate le contexte, mais expose à des erreurs de parsing dues à la taille excessive.

Les limites frappent aussi sur le nombre et la taille des outils : un catalogue complet surcharge la fenêtre dès le démarrage. Sans optimisation, les agents MCP plafonnent à des tâches simples, inadaptées à l’automatisation d’entreprise où les volumes de données croissent exponentiellement.

L’innovation code-first d’Anthropic pour des agents scalables

Anthropic repense le MCP en le plaçant dans une boucle d’exécution de code, faisant passer les agents d’un paradigme outil-centré à un système code-first, où le LLM devient un développeur virtuel.

Architecture : du client MCP à une API de code sandboxed

Le client MCP se métamorphose en une abstraction de système de fichiers, exposant les serveurs comme des modules de code – des API de niveau code. Au lieu d’appels directs, le modèle génère du TypeScript pour importer et composer ces modules dans un environnement sandboxed. Ce bac à sable isole l’exécution, limitant les ressources et surveillant les flux.

Le processus se décompose en trois étapes précises. D’abord, un répertoire « servers » liste les outils MCP disponibles. Ensuite, des wrappers TypeScript fins encapsulent chaque outil, comme « servers/google-drive/getDocument.ts ». Enfin, le LLM orchestre le tout via un script maître, déplaçant les gros payloads hors du contexte modèle.

Cette idée évoque le « Code Mode » de Cloudflare pour sa plateforme Workers, où le code généré pilote les interactions serveur sans alourdir le contexte.

Avantages systémiques : réduction des tokens et nouvelles fonctionnalités

Les gains chiffrés impressionnent : un workflow traditionnel à 150 000 tokens tombe à 2 000 tokens, une réduction de 98,7 %. Dans des pipelines de données plus lourds, le ratio atteint 99,6 %, de 250 000 à 900 tokens. La latence s’effondre pour les tâches complexes, car les données restent dans l’environnement d’exécution.

La découverte progressive des outils change la donne : l’agent explore le filesystem « servers/ » et charge seulement les interfaces requises, évitant les catalogues exhaustifs au démarrage. Les grands datasets se filtrent ou agrègent en code, ne renvoyant qu’un résumé au modèle. Pour la confidentialité, les champs sensibles se tokenisent dans le sandbox, le LLM voyant des placeholders neutres.

Enfin, l’état persistant via un répertoire « skills/ » connecte à « Claude Skills » d’Anthropic, stockant des scripts réutilisables pour reprendre des tâches interrompues. Les ingénieurs gagnent en flexibilité pour des workflows avec boucles, conditions et gestion d’erreurs natives en TypeScript.

Considérations architecturales : entre sécurité et compromis

Malgré ses promesses, l’approche code-first impose des choix techniques qui ne conviennent pas à tous les scénarios, soulignant les tensions inhérentes à l’innovation en IA.

Sécurité impérative dans l’environnement d’exécution

L’exécution de code généré requiert un sandbox robuste : limites CPU, mémoire, et surveillance pour prévenir les fuites ou abus. Anthropic insiste sur cette infrastructure pour protéger les systèmes hôtes contre les injections malveillantes. Sans ces garde-fous, le risque d’escalade de privilèges nullifie les gains en scalabilité.

Cette couche sécurisée préserve aussi la souveraineté des données, alignée sur les normes européennes comme le RGPD, en gardant les payloads sensibles hors du LLM.

Complexité accrue et latence pour les opérations basiques

Le passage au code-first alourdit l’implémentation : wrapper, orchestration, gestion du filesystem demandent plus de développement initial. Pour des opérations simples – comme une requête unique – la latence bondit de 3 à 10 fois, passant de moins d’une seconde à 5-15 secondes. Cela freine les cas d’usage triviaux où la simplicité prime.

Le code comme remède au goulot d’étranglement contextuel

Cependant, pour les applications en production, ces compromis s’effacent devant les bénéfices. Le LLM excelle en génération de code, contournant sa faiblesse en gestion de fenêtre de contexte. Les flux de contrôle natifs – boucles, exceptions – enrichissent les agents, rendant le MCP viable à l’échelle.

Les ingénieurs, face à des workflows comme l’intégration CRM ou l’analyse de logs, trouvent ici un outil puissant pour l’automatisation durable, même si l’adoption progressive s’impose pour maîtriser la courbe d’apprentissage.