Benchmark

Exécution de code avec MCP: une nouvelle approche pour l'efficacité des agents IA

avec

mis à jour le 24 juin 2026

Anthropic a introduit une méthode dans laquelle les agents IA interagissent avec des serveurs Model Context Protocol (MCP) en écrivant du code exécutable plutôt qu’en effectuant des appels directs aux outils. L’agent traite les outils comme des fichiers sur un ordinateur, trouve ce dont il a besoin et les utilise directement avec du code, de sorte que les données intermédiaires n’ont pas à passer par la mémoire du modèle. Nous avons testé cette approche pour voir si elle réduit le coût en tokens tout en maintenant le même taux de succès.

Exécution de code avec MCP vs MCP standard

Métrique	MCP standard	MCP avec exécution de code	Différence
Taux de succès	100%	100%	Identique
Latence moyenne	9.66s	10.37s	+7%
Tokens d’entrée moyens	15,417	3,310	-78.5%
Tokens de sortie moyens	87	192	+120%
Total tokens d’entrée	770,852	165,496	-78.5%
Total tokens de sortie	4,345	9,585	+120%
Total de tous les tokens	775,197	175,081	-77.4%

Nous avons comparé deux approches pour construire des agents IA qui interagissent avec des outils externes via le MCP :

MCP standard : approche traditionnelle où toutes les définitions d’outils sont chargées dans la fenêtre de contexte du modèle
MCP avec exécution de code : nouvelle approche où le modèle écrit du code qui appelle les outils, gardant les données intermédiaires hors du contexte

Principales conclusions

Économies de tokens d’entrée : l’exécution de code utilise 78.5% de tokens d’entrée en moins (165K contre 771K) :

Le standard charge ~15,400 tokens de définitions d’outils par appel
L’exécution de code n’a besoin que d’environ 3,300 tokens par appel

Tokens de sortie plus élevés : l’approche d’exécution de code utilise 2.2× plus de tokens de sortie car le modèle écrit du code et des explications

Économies nettes de tokens : 77.4% de réduction totale des tokens (175K contre 775K)

Implication en termes de coût :

Les tokens d’entrée sont généralement moins chers que les tokens de sortie
Mais les économies d’entrée de 78% l’emportent largement sur une augmentation de 2× des sorties
Réduction de coût estimée à ~70% avec l’exécution de code

Les deux ont atteint un taux de succès de 100% sur ces requêtes avec GPT-4.1.

L’approche d’exécution de code s’inspire de l’article d’Anthropic sur l’utilisation de l’exécution de code avec MCP pour réduire l’utilisation de la fenêtre de contexte tout en maintenant les capacités de l’agent.¹

Méthodologie de la comparaison de l’exécution de code avec MCP

Tâches

Nous exécutons chaque tâche 50 fois pour chaque approche :

Aller sur https://aimultiple.com/open-source-embedding-models, indiquez-moi les 5 meilleurs modèles parfaits (c’est-à-dire les modèles avec une précision de 100% dans le top 5)
Aller sur https://aimultiple.com/open-source-embedding-models, indiquez-moi quel modèle a la latence la plus élevée.

Configuration de la comparaison

Nous avons utilisé le serveur Bright Data MCP avec le mode pro activé, car il avait la plus haute précision dans notre benchmark de navigateur MCP.

Bright Data MCP server : outils d’intégration web pour l’IA.

Visitez le site web

Nous avons utilisé GPT-4.1 comme LLM en raison de sa grande fenêtre de contexte.

Configuration de l’environnement : Nous avons effacé toutes les données en cache et assuré une nouvelle connexion au serveur MCP à chaque exécution. Chaque requête est exécutée en tant que sous-processus distinct.

Comparaison des architectures

Architecture MCP standard

Dans l’approche MCP standard, l’agent suit un flux simple : la requête de l’utilisateur entre dans un agent LangGraph ReAct, qui a accès aux 63 définitions d’outils dans sa fenêtre de contexte. L’agent sélectionne et appelle les outils via la session client MCP, et les résultats des outils retournent par la fenêtre de contexte pour informer l’action suivante de l’agent.

Architecture MCP avec exécution de code

L’approche d’exécution de code ajoute une couche intermédiaire : la requête de l’utilisateur va à un agent d’exécution de code avec un contexte compact (seulement les noms des outils, pas les schémas complets). L’agent écrit du code Python qui appelle les outils. Ce code s’exécute dans un environnement d’exécution de code isolé (sandbox), qui communique avec la session client MCP. Seuls les résultats finaux ou les résumés retournent au contexte de l’agent, pas les données intermédiaires brutes.

L’implémentation de l’exécution de code utilise une divulgation progressive. Seuls les noms des outils et les descriptions tronquées (60 caractères) sont inclus dans le prompt système. Lorsque le modèle a besoin d’utiliser un outil, il écrit du code Python qui appelle une fonction asynchrone call_tool() fournie dans l’environnement d’exécution.

Limites de notre approche

Diversité des requêtes : Seuls 2 types de requêtes testés ; les résultats peuvent varier pour d’autres types de tâches.
Modèle unique : Testé uniquement avec GPT-4.1 ; d’autres modèles peuvent montrer des schémas différents
Qualité du code : Le succès de l’exécution de code dépend de la capacité de génération de code du modèle, ce qui peut entraîner une baisse des taux de succès dans des tâches plus complexes.

Laissez notre équipe automatiser l'un de vos processus métier avec des agents IA, gratuitement.

Automatiser un processus

Pourquoi le MCP traditionnel gaspille des ressources

Problème 1 : Les définitions d’outils consomment un contexte excessif

Chaque outil nécessite des instructions dans la mémoire du modèle. Un exemple basique :

gdrive.getDocument
Gets a file from Google Drive
Needs: document ID
Returns: the file content

Exemple : Un agent connecté à 50 serveurs avec 20 outils chacun signifie 1,000 définitions d’outils. À environ 150 tokens par définition, cela fait 150,000 tokens consommés avant que l’agent ne lise votre première requête.

Problème 2 : Les données sont traitées plusieurs fois

Tâche : « Obtenir mes notes de réunion de Google Drive et les ajouter à Salesforce. »

Ce qui se passe :

L’agent obtient le document (50,000 tokens)
Le modèle lit
L’agent l’envoie à Salesforce (encore 50,000 tokens)

Le modèle gère plus de 100,000 tokens pour déplacer des données d’un endroit à un autre.
Les implémentations MCP traditionnelles exigent que le modèle sélectionne des outils à partir de définitions JSONSchema chargées dans la fenêtre de contexte, ce qui dégrade la précision à mesure que le nombre d’outils augmente.² Des recherches ont confirmé que les taux de réussite des tâches baissent fortement à mesure que le nombre d’outils disponibles augmente en raison de l’inondation du contexte par les définitions de schéma.³ Exposer les outils MCP en tant que fonctions appelables et permettre au modèle d’écrire du code Python qui invoque directement les outils tire parti de la capacité existante de génération de code du modèle plutôt que de forcer la sélection à partir de schémas prédéfinis.

Quand utiliser l’exécution de code avec MCP ?

L’exécution de code avec MCP répond à deux inefficacités fondamentales des implémentations MCP traditionnelles :

Les définitions d’outils n’encombrent plus la fenêtre de contexte
Les données intermédiaires ne transitent plus inutilement par le modèle

L’approche fonctionne le mieux lorsque :

Vous avez de nombreux outils MCP connectés
Vos flux de travail impliquent un traitement de données en plusieurs étapes
De grands documents ou ensembles de données circulent entre les outils
Les limites de la fenêtre de contexte affectent vos agents

Les exigences d’infrastructure signifient que cela n’est pas automatiquement meilleur pour tous les cas d’usage. Les déploiements à petite échelle avec peu d’outils pourraient ne pas justifier la complexité opérationnelle.

Pour les organisations qui exécutent déjà des agents avec de vastes catalogues d’outils MCP, le potentiel de réduction de plus de 98% des tokens et les économies de coûts correspondantes rendent cette approche digne d’intérêt.

Ne manquez pas nos benchmarks et analyses basées sur les données. Le bouton ouvre Google ; sélectionner AIMultiple confirme que vous souhaitez voir AIMultiple plus souvent dans les résultats de recherche Google.

Ajouter comme source préférée

Frameworks et protocoles alternatifs

Au-delà de LangGraph, l’Agent Development Kit (ADK) de Google offre une prise en charge native de MCP via McpToolset et s’intègre au protocole Agent2Agent (A2A), qui standardise la communication d’agent à agent via des cartes de capacités publiées à /.well-known/agent-card.json.⁴⁵ En avril 2026, OpenAI a mis à jour son SDK Agents pour ajouter des capacités d’exécution native en sandbox, offrant des espaces de travail isolés avec un accès restreint aux fichiers et au code.⁶

Citer cette recherche

Choisissez le format qui correspond à votre lieu de publication. Coller la version avec lien dans votre CMS préserve le lien retour.

Sena Sezer and Şevval Alper (2026) - "Exécution de code avec MCP: une nouvelle approche pour l'efficacité des agents IA". Publié en ligne sur AIMultiple.com. Consulté le 24 Juin 2026, à : https://aimultiple.com/code-execution-with-mcp [Ressource en ligne]

Sezer, S., & Alper, Ş. (2026, 24 Juin). Exécution de code avec MCP: une nouvelle approche pour l'efficacité des agents IA. AIMultiple. https://aimultiple.com/code-execution-with-mcp

@misc{sezer2026,
  author = {Sezer, Sena and Alper, Şevval},
  title  = {{Exécution de code avec MCP: une nouvelle approche pour l'efficacité des agents IA}},
  year   = {2026},
  month  = jun,
  howpublished    = {\url{https://aimultiple.com/code-execution-with-mcp}},
  note   = {AIMultiple. Consulté le 24 Juin 2026}
}