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

Anthropic a introduit une méthode dans laquelle les agents IA interagissent avec les serveurs Model Context Protocol (MCP) en écrivant du code exécutable plutôt que de faire 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 réussite.

Exécution de code avec MCP vs MCP standard

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 : approche novatrice où le modèle écrit du code qui appelle les outils, en 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 vs 771K) :

• Le MCP standard charge ~15,400 tokens de définitions d'outils par appel
• L'exécution de code nécessite seulement ~3,300 tokens par appel

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

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

Implication du coût :

• Les tokens d'entrée sont généralement moins chers que les tokens de sortie
• Mais 78% d'économies d'entrée l'emportent largement sur l'augmentation de 2× des tokens de sortie
• Estimation d'une réduction de coût d'environ 70% avec l'exécution de code

Les deux ont atteint un taux de réussite de 100% sur ces requêtes avec GPT-4.1.

L'approche d'exécution de code est inspirée par 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 la capacité de l'agent.¹

Méthodologie de la comparaison d'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, me dire les 5 meilleurs performeurs parfaits (c'est-à-dire les modèles avec une précision top-5 de 100%)
• Aller sur https://aimultiple.com/open-source-embedding-models, me dire quel modèle a la latence la plus élevée.

Configuration de la comparaison

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

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 par exécution. Chaque requête est exécutée en tant que sous-processus séparé.

Comparaison des architectures

Architecture MCP standard

Dans l'approche MCP standard, l'agent suit un flux simple : la requête utilisateur entre dans un agent LangGraph ReAct, qui a accès à toutes les 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 la prochaine action 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 utilisateur va à un agent d'exécution de code avec un contexte compact (seulement les noms d'outils, pas les schémas complets). L'agent écrit du code Python qui appelle les outils. Ce code s'exécute dans un environnement sandbox d'exécution de code, 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 d'outils et des descriptions tronquées (60 caractères) sont inclus dans l'invite du 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

1. Diversité des requêtes : Seulement 2 types de requêtes testés ; les résultats peuvent varier pour d'autres types de tâches.
2. Modèle unique : Testé uniquement avec GPT-4.1 ; d'autres modèles peuvent montrer des schémas différents
3. 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 réussite dans les tâches plus compliquées.

Pourquoi le MCP traditionnel gaspille des ressources

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

Chaque outil a besoin d'instructions dans la mémoire du modèle. Un exemple simple :

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 :

1. L'agent obtient le document (50,000 tokens)
2. Le modèle le lit
3. L'agent l'envoie à Salesforce (encore 50,000 tokens)

Le modèle traite 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.² La recherche a confirmé que les taux de réussite des tâches diminuent fortement à mesure que le nombre d'outils disponibles augmente en raison de l'encombrement 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é de génération de code existante du modèle plutôt que de forcer une sélection à partir de schémas prédéfinis.

Découvrez davantage de nos benchmarks et analyses basées sur les données dans la recherche Google.

Ajouter comme source préférée

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

L'exécution de code avec MCP résout deux inefficacités fondamentales des implémentations MCP traditionnelles :

1. Les définitions d'outils n'encombrent plus la fenêtre de contexte
2. Les données intermédiaires cessent de transiter 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 se déplacent entre les outils
• Les limites de la fenêtre de contexte affectent vos agents

Les exigences d'infrastructure signifient que ce n'est pas automatiquement meilleur pour tous les cas d'utilisation. 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 tokens de plus de 98% et les économies de coûts correspondantes rendent cette approche digne d'intérêt.

Frameworks et protocoles alternatifs

Au-delà de LangGraph, le kit de développement d'agent (ADK) de Google offre une prise en charge native de MCP via McpToolset et s'intègre avec le protocole Agent2Agent (A2A), qui standardise la communication d'agent à agent via des cartes de capacité publiées à /.well-known/agent-card.json.^{4 5} En avril 2026, OpenAI a mis à jour son SDK Agents pour ajouter des capacités d'exécution sandbox natives, 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.

@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}
}

Liens de référence

1.

Code execution with MCP: building more efficient AI agents \ Anthropic

2.

Code execution with MCP: building more efficient AI agents \ Anthropic

3.

https://arxiv.org/pdf/2603.20313

4.

Developer’s Guide to AI Agent Protocols - Google Developers Blog

5.

MCP tools - Agent Development Kit (ADK)

6.

OpenAI updates its Agents SDK to help enterprises build safer, more capable agents | TechCrunch

TechCrunch

Sena Sezer

Analyste du secteur

Suivre

Sena est analyste sectorielle chez AIMultiple. Elle a obtenu sa licence à l'Université de Bogazici.

Voir le profil complet

Recherche effectuée par

Şevval Alper

Chercheur en IA

Suivre

Şevval est analyste chez AIMultiple, spécialisé dans les outils de codage IA, les agents IA et les technologies quantiques.

Voir le profil complet

Soyez le premier à commenter

Votre adresse courriel ne sera pas publiée. Tous les champs sont obligatoires. Les commentaires sont laissés dans leur langue d'origine.

Nom

Adresse email

Commentaire

0/450

Publier un commentaire