La fin du MCP pour les agents IA ? Pourquoi l’exécution de code est une meilleure abstraction

Introduction

Le développement des agents IA connaît un bouleversement fondamental. Des analyses récentes de leaders du secteur remettent en question l’un des standards les plus largement adoptés : le Model Context Protocol (MCP). Bien que le MCP ait été conçu pour standardiser la façon dont les agents IA interagissent avec les systèmes externes, des preuves émergentes montrent que cette abstraction pourrait en fait limiter la performance des agents, augmenter les coûts et réduire leur autonomie. Dans ce guide complet, nous verrons pourquoi l’exécution de code émerge comme une alternative supérieure au MCP, comment elle peut réduire la consommation de tokens jusqu’à 98 %, et ce que cela implique pour l’avenir de l’architecture des agents IA. Que vous développiez des systèmes IA d’entreprise ou exploriez l’automatisation basée sur les agents, comprendre ce changement de paradigme est essentiel pour faire les bons choix architecturaux.

Comprendre le Model Context Protocol : ce que c’est et pourquoi il a émergé

Le Model Context Protocol représente une tentative significative de standardisation du développement des agents IA. À la base, le MCP est une norme ouverte destinée à connecter les agents IA à des systèmes externes, des API et des sources de données. Le principe fondamental du MCP est élégant : au lieu que chaque développeur construise des intégrations sur mesure entre ses agents IA et les outils externes, le MCP offre un protocole universel permettant d’implémenter des intégrations une fois pour toutes, puis de les partager dans tout l’écosystème. Cette standardisation a transformé la communauté IA, rendant possible une collaboration et un partage d’outils sans précédent au niveau mondial.

D’un point de vue technique, le MCP est essentiellement une spécification d’API optimisée pour la consommation par des agents IA plutôt que pour des développeurs humains. Alors que les API traditionnelles sont pensées pour l’expérience développeur, les MCP sont spécifiquement architecturés pour être consommés par des modèles de langage et des agents autonomes. Le protocole définit comment les agents doivent demander des informations, comment les outils doivent être décrits et comment les résultats doivent être formatés pour une compréhension optimale. La véritable innovation du MCP n’était pas tant le protocole lui-même, mais son adoption à l’échelle de l’industrie, créant un écosystème unifié. Quand Anthropic et d’autres acteurs majeurs se sont alignés sur le MCP, cela signifiait que les développeurs pouvaient créer des outils une fois et les faire fonctionner sans friction sur plusieurs plateformes et implémentations d’agents.

La proposition de valeur du MCP est attrayante : il promet d’ouvrir tout un écosystème d’intégrations, de réduire le temps de développement et de permettre aux agents d’accéder à des milliers d’outils sans ingénierie sur mesure pour chaque connexion. Cette standardisation a entraîné la prolifération rapide de serveurs MCP dans l’industrie, avec des développeurs créant des serveurs spécialisés pour tout, de l’accès aux bases de données à l’intégration d’API tierces. L’idée étant que plus le nombre de serveurs MCP disponibles augmentait, plus les agents deviendraient autonomes et capables de traiter des tâches complexes grâce à un riche écosystème d’outils préconstruits.

Les coûts cachés du MCP : pourquoi la consommation de tokens et l’autonomie des agents comptent

Si le MCP a résolu le problème de la standardisation, il a également introduit de nouveaux défis, de plus en plus évidents à mesure que les agents IA gagnent en sophistication et sont déployés à grande échelle. L’enjeu majeur est la surconsommation de tokens, qui impacte directement le coût et la performance des agents IA. Comprendre ce phénomène nécessite d’examiner comment les serveurs MCP sont généralement mis en œuvre et comment les agents interagissent réellement avec eux.

Lorsqu’un agent IA se connecte à un serveur MCP, il reçoit une documentation détaillée sur chaque outil disponible dans ce serveur. Un serveur MCP typique contient entre 20 et 30 outils différents, chacun avec des descriptions, des spécifications de paramètres et des exemples d’utilisation détaillés. En pratique, les organisations connectent rarement un seul serveur MCP à leurs agents. Au contraire, elles en intègrent généralement cinq, six, voire plus, pour offrir une large palette de capacités. Cela signifie que même si un agent n’a besoin que d’un outil spécifique, toute la fenêtre de contexte est remplie des descriptions et métadonnées de tous les outils disponibles sur tous les serveurs connectés. C’est la première grande source de gaspillage de tokens : les agents portent des informations sur des outils inutiles, ce qui augmente latence et coût tout en favorisant les hallucinations.

La deuxième grande source de consommation de tokens provient des résultats intermédiaires des outils. Prenons un exemple concret : un agent doit récupérer une transcription depuis Google Drive pour extraire une information précise. L’outil MCP de récupération de documents peut renvoyer 50 000 tokens de contenu, voire dépasser complètement la limite de la fenêtre de contexte pour un document volumineux. Or, l’agent n’a souvent besoin que du premier paragraphe ou d’une section spécifique. Malgré cela, l’intégralité du document transite par la fenêtre de contexte, consommant inutilement des tokens et risquant de dépasser les limites disponibles. Cette inefficacité se multiplie à chaque appel d’outil, et dans des workflows complexes comportant des dizaines d’étapes, le gaspillage est colossal.

Au-delà de la consommation de tokens, il existe une problématique architecturale plus profonde : le MCP réduit l’autonomie des agents. Chaque couche d’abstraction ajoutée à un système d’agents limite ce que l’agent peut faire et sa capacité à résoudre des problèmes de manière flexible. En forçant les agents à opérer dans les contraintes de définitions d’outils prédéfinies et d’interfaces MCP figées, on leur ôte la capacité d’adaptation, de transformation de données ou de création de solutions personnalisées. Or, le but fondamental des agents IA est d’exécuter des tâches de façon autonome, mais la couche d’abstraction du MCP va à l’encontre de cet objectif en limitant leur souplesse et leur prise de décision.

Pourquoi l’exécution de code est la meilleure abstraction pour les agents IA

L’approche alternative qui gagne du terrain consiste à exploiter une capacité fondamentale des modèles de langage modernes : la génération de code. Plutôt que de s’appuyer sur des définitions d’outils prédéfinies et des interfaces MCP figées, cette approche permet aux agents de générer et d’exécuter du code directement, appelant les API et outils nécessaires via le code plutôt qu’un protocole standardisé. Ce changement représente une refonte profonde de la façon dont les agents devraient interagir avec les systèmes externes.

L’architecture de cette approche par exécution de code est d’une grande simplicité. Au lieu de se connecter à des serveurs MCP, le système maintient une hiérarchie de dossiers structurée où chaque dossier représente un serveur MCP, et à l’intérieur de chaque dossier se trouvent des sous-dossiers pour les catégories d’outils, contenant des fichiers TypeScript simples qui implémentent chaque outil. Lorsqu’un agent doit utiliser un outil, il ne recherche pas une définition prédéfinie dans la fenêtre de contexte : il génère du code qui importe l’outil nécessaire depuis le bon dossier et l’appelle directement. Cela change fondamentalement la circulation de l’information dans le système et la façon dont les agents accèdent aux capacités externes.

Les gains de performance sont spectaculaires. En ne transmettant que la définition de l’outil réellement nécessaire à l’agent, et non tous les outils de tous les serveurs connectés, la consommation de tokens pour les définitions d’outils chute drastiquement. Plus encore, les agents peuvent désormais gérer intelligemment les résultats intermédiaires. Plutôt que de faire passer un document de 50 000 tokens dans la fenêtre de contexte, un agent peut sauvegarder ce document sur le système de fichiers puis n’en extraire que l’information utile. Dans des implémentations réelles, cette approche a démontré des réductions de consommation de tokens allant jusqu’à 98 % par rapport aux solutions MCP traditionnelles, tout en améliorant simultanément la performance et l’autonomie des agents.

Divulgation progressive : un accès illimité aux outils sans surcharge de contexte

L’un des avantages majeurs de l’exécution de code est la « divulgation progressive ». Avec le MCP traditionnel, les agents sont limités par la taille de la fenêtre de contexte—il y a une limite pratique au nombre d’outils qu’on peut connecter avant que la fenêtre ne soit surchargée. Avec l’exécution de code, cette limite disparaît quasiment. Un agent peut théoriquement accéder à des milliers de serveurs MCP et d’outils, mais il ne charge que ceux dont il a besoin à un instant T.

Ceci est rendu possible par un mécanisme de recherche qui permet aux agents de découvrir les outils et serveurs MCP disponibles. Quand un agent doit réaliser une tâche nécessitant un outil qu’il n’a jamais utilisé, il peut parcourir les outils existants, choisir le bon, puis l’importer et l’utiliser. Ainsi, on obtient une architecture scalable où le nombre d’outils n’impacte pas la performance de l’agent. Les organisations peuvent bâtir des écosystèmes d’outils complets sans craindre de dépasser les limites de contexte, et les agents découvrent et utilisent de nouveaux outils à la volée, sans redéploiement ni reconfiguration.

Les implications sont considérables. Une grande entreprise peut posséder des centaines d’API internes, bases de données et services qu’elle souhaite rendre accessibles à ses agents. Avec le MCP traditionnel, connecter tous ces outils surchargerait la fenêtre de contexte. Avec la divulgation progressive par exécution de code, les agents peuvent accéder efficacement à l’ensemble de cet écosystème, découvrant et utilisant les outils au besoin. Cela permet de véritables capacités d’agents à grande échelle sans les pénalités de performance du MCP traditionnel.

Confidentialité et protection des données grâce à l’exécution de code

Les entreprises, notamment dans les secteurs réglementés, accordent une importance cruciale à la confidentialité et à la protection des données. Avec le MCP traditionnel et les fournisseurs de modèles externes comme Anthropic ou OpenAI, toutes les données transitant par l’agent—y compris des informations sensibles, clients ou propriétaires—sont transmises à l’infrastructure du fournisseur du modèle. Cela est souvent inacceptable pour des organisations soumises à de fortes contraintes de gouvernance ou à la conformité réglementaire.

L’approche par exécution de code apporte une solution avec ce qu’on appelle une « data harness ». En mettant en œuvre l’exécution de code dans un environnement contrôlé, les organisations peuvent ajouter une couche qui anonymise ou masque automatiquement les données sensibles avant qu’elles ne soient exposées à des fournisseurs tiers. Par exemple, un outil qui récupère des données clients depuis une feuille de calcul peut être modifié pour anonymiser automatiquement les adresses e-mail, numéros de téléphone, etc. L’agent accède toujours aux données nécessaires à la tâche, mais les informations sensibles sont protégées contre toute exposition externe.

Cette capacité est particulièrement précieuse pour les données de santé, financières ou réglementées. Plutôt que de devoir choisir entre capacités des agents et confidentialité, les organisations peuvent bénéficier des deux. L’agent accède aux données utiles, mais les informations sensibles sont protégées automatiquement via la data harness. Cette approche séduit particulièrement les clients entreprises qui souhaitent tirer parti des agents IA sans accepter les risques de confidentialité du MCP classique.

Persistance d’état et évolution des compétences agents

Peut-être le bénéfice le plus transformateur de l’exécution de code est la capacité pour les agents de créer, persister et faire évoluer leurs propres compétences. Avec le MCP traditionnel, l’ensemble des outils disponibles est figé lors du déploiement—un agent ne peut ni créer de nouveaux outils ni modifier l’existant. Avec l’exécution de code, les agents peuvent générer de nouvelles fonctions et les enregistrer sur le système de fichiers, créant ainsi des compétences persistantes réutilisables dans de futures tâches.

Cette capacité est liée à la notion émergente de « skills » dans l’architecture agent, récemment introduite par les instituts de recherche en IA. On ne considère plus les agents comme dotés d’un set de capacités fixes, mais comme possédant un ensemble de compétences qui grandit et évolue avec le temps. Lorsqu’un agent rencontre une tâche nécessitant une capacité nouvelle, il peut la créer, la tester, puis la sauvegarder pour un usage ultérieur. Progressivement, les agents deviennent de plus en plus spécialisés et compétents dans leur domaine ou cas d’usage.

Pour le développement agent, cela change la donne : les développeurs n’ont plus à anticiper tous les outils possibles, les agents peuvent créer leurs propres outils au fil des besoins. On passe ainsi à une approche adaptative et évolutive, où les capacités émergent naturellement des usages réels. Un agent œuvrant dans un domaine spécifique pourra ainsi développer un ensemble riche de compétences spécialisées que le développeur n’aurait jamais imaginé construire manuellement.

Mise en œuvre de l’architecture d’exécution de code par FlowHunt

FlowHunt a identifié les limites du MCP traditionnel et construit son infrastructure agent autour de l’exécution de code. Ce choix architectural traduit une compréhension fine de ce qui rend les agents véritablement autonomes et efficaces. En faisant de l’exécution de code le mécanisme principal d’interaction agent-outil, FlowHunt permet à ses utilisateurs de concevoir des agents plus efficaces, autonomes et rentables que ceux bâtis sur le MCP classique.

La plateforme FlowHunt fournit l’infrastructure nécessaire pour appliquer l’exécution de code en toute sécurité et fiabilité : environnement sandbox sécurisé, journalisation et supervision complètes pour suivre le comportement des agents, et mécanismes de protection des données intégrés. Plutôt que de contraindre les utilisateurs à bâtir cette infrastructure eux-mêmes, FlowHunt l’offre en service managé, permettant de se concentrer sur la conception d’agents performants.

L’approche FlowHunt intègre aussi la divulgation progressive, permettant de connecter des centaines, voire des milliers d’outils et d’API sans perte de performance. La plateforme gère la découverte d’outils, la génération et l’exécution de code de façon optimisée pour la performance et la fiabilité. Les utilisateurs peuvent bâtir des écosystèmes d’agents évolutifs, où les agents découvrent et utilisent de nouvelles capacités à la demande.

Limites pratiques et compromis de l’exécution de code

Si l’exécution de code offre des avantages significatifs, il est important d’en reconnaître les limites et compromis. Premièrement, la fiabilité : à chaque fois qu’un agent doit générer du code pour appeler un outil, il y a plus de risques d’erreur. L’agent peut générer un code incorrect, commettre des erreurs logiques ou mal comprendre les paramètres d’une API. Cela nécessite une gestion robuste des erreurs, des mécanismes de reprise et parfois une supervision humaine pour des opérations critiques. Le MCP traditionnel, avec ses définitions et interfaces figées, est naturellement plus fiable car il laisse moins de place à l’erreur.

Deuxième limite : la charge d’infrastructure. Mettre en œuvre l’exécution de code en toute sécurité implique un environnement sandbox isolé, contrôlé et surveillé. Ce sandbox doit être séparé du système principal, avoir des accès réseau contrôlés et être constamment supervisé. Sa mise en place requiert un effort d’ingénierie conséquent. Les organisations envisageant cette approche doivent donc construire cette infrastructure ou recourir à une plateforme telle que FlowHunt.

D’autres considérations opérationnelles existent : l’exécution de code exige une supervision et une journalisation plus sophistiquées pour comprendre les actions des agents et les déboguer. Le MCP, avec ses outils fixes, est plus simple à superviser car les actions sont plus prévisibles. Avec l’exécution de code, la liberté accrue des agents multiplie les comportements inattendus à investiguer.

Quand le MCP reste pertinent : cas d’usage et scénarios

Malgré les avantages de l’exécution de code, le MCP ne devient pas obsolète. Certains scénarios lui restent adaptés. Les cas d’usage simples avec peu de complexité API sont de bons candidats pour le MCP. Par exemple, des scénarios de support client où un agent crée des tickets, consulte leur statut ou accède à une base de connaissances ne nécessitent pas la flexibilité de l’exécution de code : les API sont simples, les transformations de données minimes, et la fiabilité des interfaces MCP prévaut sur la souplesse de l’exécution de code.

Le MCP est aussi pertinent pour les outils destinés à être utilisés par de nombreux agents et organisations. Si vous créez un outil à partager dans l’écosystème, le proposer comme serveur MCP le rend accessible à une large communauté. La standardisation du MCP est précieuse pour la distribution et la mutualisation des outils, même si ce n’est pas optimal pour la performance individuelle des agents.

Enfin, pour les organisations n’ayant pas l’expertise ni les ressources pour mettre en place une exécution de code sécurisée, le MCP offre un chemin plus simple vers les agents IA. Le compromis se fait sur la performance et l’autonomie, mais la simplicité et la fiabilité peuvent primer dans certains contextes.

Le principe architectural fondamental : réduire les couches d’abstraction

La transition du MCP vers l’exécution de code illustre un principe architectural général : chaque couche d’abstraction ajoutée à un système agent réduit son autonomie et sa flexibilité. En forçant les agents à passer par des interfaces et des outils prédéfinis, on bride leur capacité. Les modèles de langage modernes sont devenus remarquablement performants en génération de code ; il devient donc logique de leur laisser manipuler directement le code et les API, plutôt que de les contraindre à travers des couches intermédiaires.

Ce principe dépasse le seul MCP. Il suggère qu’à mesure que les agents IA gagnent en capacité, il faut leur donner un accès plus direct aux systèmes et données nécessaires, plutôt que d’empiler les abstractions. Chaque couche ajoutée accroît la complexité, la consommation de tokens et réduit l’adaptabilité de l’agent. Les architectures les plus performantes seront probablement celles qui minimisent l’abstraction inutile et laissent les agents interagir le plus directement possible avec les systèmes sous-jacents.

Il ne s’agit pas d’éliminer toute abstraction—un certain niveau de structure et de garde-fous reste nécessaire. Mais il faut être intentionnel dans le choix des abstractions à ajouter. L’exécution de code est une approche plus directe et moins abstraite, et les gains de performance démontrent que le surcroît de complexité d’infrastructure en vaut la peine.

Considérations de mise en œuvre et bonnes pratiques

Pour les organisations envisageant la transition du MCP vers l’exécution de code, plusieurs points d’attention s’imposent. D’abord, établir un environnement sandbox sécurisé : cela peut consister en un conteneur, une machine virtuelle, ou un service spécialisé pour l’exécution de code. Le sandbox doit être isolé des systèmes principaux, avoir un accès réseau contrôlé et être supervisé en continu. Deuxièmement, il faut une gestion robuste des erreurs et des mécanismes de reprise. Puisque les agents génèrent du code, il faut anticiper erreurs de syntaxe, erreurs logiques et échecs API. Le système doit pouvoir détecter ces erreurs, fournir un retour exploitable à l’agent, et permettre des reprises ou alternatives.

Troisièmement, il est crucial de définir des conventions claires sur l’organisation et le nommage des outils. La structure des dossiers et les conventions choisies auront un impact direct sur la facilité avec laquelle les agents découvriront et utiliseront les outils. Des outils bien nommés et organisés sont plus facilement exploitables par les agents. Quatrièmement, il faut intégrer des mécanismes de protection des données dès le départ : anonymisation, masquage, etc. Une stratégie claire de protection des données qui transitent par le système agent est essentielle.

Enfin, il faut investir dans la supervision et l’observabilité. L’exécution de code accroît la complexité et le risque de comportements imprévus. Une journalisation complète, une surveillance et des alertes permettront de comprendre les actions des agents et de réagir rapidement aux incidents.

L’avenir de l’architecture agent

Le passage du MCP à l’exécution de code marque une évolution profonde de la conception de l’architecture agent. À mesure que les agents deviennent plus puissants et répandus, on constate que les abstractions conçues pour les systèmes moins avancés deviennent des freins. L’avenir de l’architecture agent verra probablement des interactions encore plus directes entre agents et systèmes, avec moins de couches intermédiaires.

Cette évolution s’accompagnera d’améliorations en fiabilité et sécurité. En donnant plus d’accès direct aux agents, il faudra de meilleurs mécanismes pour assurer une utilisation responsable : sandboxing sophistiqué, supervision renforcée, ou nouveaux paradigmes d’alignement et de contrôle. L’objectif reste de maximiser l’autonomie et l’efficacité des agents tout en préservant la sécurité.

Les méthodes de découverte et d’utilisation des outils évolueront aussi. La divulgation progressive en est une étape, mais d’autres approches plus intelligentes émergeront. Les agents apprendront peut-être à anticiper les outils nécessaires, ou à optimiser leur sélection selon la performance ou le coût.

L’exécution de code ouvre aussi la voie à l’auto-optimisation des agents. Un agent pourra générer du code pour résoudre un problème, puis analyser ce code pour l’optimiser. Progressivement, les agents élaboreront des solutions toujours plus sophistiquées et efficaces, apprenant de l’expérience.

Conclusion

L’émergence de l’exécution de code comme alternative au MCP marque un tournant dans la conception des architectures agents IA. En permettant aux agents de générer et d’exécuter du code directement, plutôt que de passer par des outils prédéfinis et des interfaces figées, on réduit considérablement la consommation de tokens, on améliore l’autonomie et on ouvre la voie à des capacités agent plus avancées. Si le MCP gardera sa place pour certains scénarios et la distribution d’outils, l’exécution de code s’impose comme la voie royale pour bâtir des agents IA autonomes et performants. La réduction de 98 % de la consommation de tokens, combinée à la hausse de performance et d’autonomie, montre que ce changement d’architecture n’est pas qu’une théorie, mais un atout concret. Alors que les organisations développent des systèmes agents plus sophistiqués, comprendre cette évolution et faire les bons choix d’architecture sera déterminant pour leur succès. L’avenir des agents IA ne réside pas dans l’accumulation de couches d’abstraction, mais dans leur suppression, pour donner aux agents l’accès direct et la flexibilité nécessaires à la résolution autonome et efficace de problèmes complexes.