Aller au contenu
Encyclopédie informatique Édition 2026

Les agents d'IA et le protocole MCP

Un assistant conversationnel répond ; un agent agit. Ranger des factures, corriger un programme, réserver une salle, comparer des offres sur plusieurs sites : depuis 2024, les intelligences artificielles génératives ne se contentent plus de rédiger, elles enchaînent des actions en utilisant des outils. Cet article explique comment fonctionne un agent d’IA, ce qu’est le protocole MCP, un standard ouvert qui permet de brancher une IA sur des logiciels et des données comme on branche un périphérique sur une prise, ce que ces agents savent faire et où ils échouent, et pourquoi leur donner des droits d’action ouvre des risques de sécurité d’un genre nouveau.

Rubrique
Données et IA
Niveau
Intermédiaire
Lecture
18 min (essentiel)
24 min (complet)
Révision
26 octobre 2026
Niveau de lecture :

En bref

  • Un agent d’IA est un système où un modèle de langage choisit lui-même, étape après étape, les actions à mener pour atteindre un objectif, en utilisant des outils et en observant leurs résultats.
  • Le modèle n’exécute rien lui-même : il produit une demande d’action structurée, que l’application exécute avant de lui rapporter le résultat ; la boucle se répète jusqu’à l’objectif.
  • Le MCP (Model Context Protocol) est un protocole ouvert qui standardise la connexion entre les applications d’IA et les outils ou données : un même serveur MCP fonctionne avec toutes les applications compatibles.
  • Les agents se trompent, et les erreurs s’accumulent au fil des étapes : il faut limiter leurs droits, journaliser leurs actions et faire valider par un humain les actions sensibles ou irréversibles.
  • Un agent qui a accès à des données privées, lit des contenus non fiables et peut communiquer vers l’extérieur peut être manipulé pour faire fuiter ces données : il faut casser cette combinaison.

Prérequis conseillés : L'IA générative et les grands modèles de langage

1Définition

Un agent d’IA est un système dans lequel un modèle de langage, le moteur des IA génératives (voir l’IA générative), ne se contente pas de répondre : il décide lui-même des actions à mener pour atteindre un objectif, les fait exécuter à l’aide d’outils, observe les résultats et ajuste la suite, étape après étape, jusqu’à ce que la tâche soit accomplie. Les outils peuvent être un moteur de recherche, un système de fichiers, une messagerie, un agenda, une base de données, un navigateur Web, un terminal de commandes ou n’importe quel logiciel doté d’une interface de programmation (voir les API).

La différence avec un assistant conversationnel classique tient en un mot : l’autonomie. À la demande « trouve-moi un créneau la semaine prochaine pour réunir l’équipe », un assistant propose une méthode ; un agent consulte les agendas, repère les créneaux libres, vérifie la disponibilité des salles et, si on l’y autorise, envoie l’invitation. On parle d’IA agentique pour désigner cette famille de systèmes. L’autonomie d’un agent n’est pas tout ou rien : elle se règle, de l’agent qui demande l’accord avant chaque action à celui qui travaille seul pendant des heures.

2De l’assistant à l’agent

L’idée d’agent logiciel est ancienne : les chercheurs en intelligence artificielle étudient depuis les années 1980 des programmes qui perçoivent leur environnement et agissent pour atteindre des buts. Mais ces agents suivaient des règles écrites à la main pour un domaine précis. Les grands modèles de langage ont changé la donne en apportant une capacité générale à comprendre une demande, à planifier et à utiliser des outils décrits en langage courant :

  • 2022 : la méthode ReAct, pour « raisonner et agir », montre qu’un modèle de langage alternant réflexions écrites et actions résout mieux les problèmes qui demandent de chercher des informations ;
  • 2023 : les éditeurs de modèles proposent l’appel d’outils, qui permet à un modèle de demander de façon structurée l’exécution d’une fonction ; des projets comme AutoGPT font sensation en enchaînant les actions sans intervention humaine, avec des résultats souvent décevants (anecdote) ;
  • 2024 : les modèles apprennent à utiliser un ordinateur comme un humain, en regardant des captures d’écran et en commandant la souris et le clavier ; en novembre, Anthropic publie le Model Context Protocol (MCP), un standard ouvert pour connecter les applications d’IA aux outils et aux données (section 4) ;
  • 2025 : les agents de programmation se généralisent (voir programmer avec l’IA), ainsi que les fonctions de « recherche approfondie » qui consultent des dizaines de sources avant de rédiger un rapport ; le MCP est adopté par les principaux éditeurs, OpenAI, Google et Microsoft, puis confié en décembre à une fondation placée sous l’égide de la Fondation Linux, l’Agentic AI Foundation.

3Comment fonctionne un agent

3.1La boucle

Au cœur de tout agent se trouve une boucle très simple (figure 1). Le modèle reçoit l’objectif, la liste des outils disponibles et tout ce qui s’est passé jusque-là. Il réfléchit, puis soit il demande une action, soit il estime avoir terminé et rédige sa réponse finale. Quand il demande une action, l’application l’exécute, ajoute le résultat au contexte, et repasse la main au modèle. Le contexte, c’est-à-dire l’ensemble du texte que le modèle prend en compte, grossit à chaque tour : il contient l’historique complet des actions et de leurs résultats.

objectif « range mes factures de mars » modèle de langage réfléchit et choisit la prochaine action demande d’action outil + paramètres « lire_dossier(Factures) » l’application exécute recherche, fichiers, code, courriel, navigateur… résultat ajouté au contexte : l’agent observe la boucle se répète jusqu’à l’objectif validation humaine si action sensible terminé réponse finale compte rendu de ce qui a été fait Le modèle n’exécute rien lui-même : il demande une action, l’application l’exécute et lui rapporte le résultat.
Figure 1. Un agent répète la même boucle : choisir une action, la faire exécuter, observer le résultat.

Prenons l’objectif « range mes factures de mars ». L’agent liste d’abord le contenu du dossier, puis ouvre chaque fichier pour en lire la date et le fournisseur, crée les sous-dossiers nécessaires, déplace les fichiers, remarque qu’une facture est illisible, la signale, et termine par un compte rendu. Aucune de ces étapes n’était programmée à l’avance : c’est le modèle qui les a choisies, en fonction de ce qu’il découvrait.

3.2L’appel d’outils

Un modèle de langage ne produit que du texte. Pour qu’il puisse agir, on lui décrit les outils disponibles : leur nom, ce qu’ils font et les paramètres qu’ils attendent. Quand il veut s’en servir, il produit une demande d’action dans un format structuré, le plus souvent JSON (JavaScript Object Notation), un format de données en texte très répandu (voir XML et JSON). L’application lit cette demande, vérifie qu’elle est autorisée, exécute l’outil et renvoie le résultat au modèle. Voici la description d’un outil, telle que le modèle la reçoit :

{
  "name": "rechercher_evenements",
  "description": "Liste les événements de l'agenda de l'utilisateur
                  entre deux dates. Ne modifie rien.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "debut": { "type": "string", "description": "date de début, AAAA-MM-JJ" },
      "fin":   { "type": "string", "description": "date de fin, AAAA-MM-JJ" }
    },
    "required": ["debut", "fin"]
  }
}

Et la demande que le modèle produit quand il veut s’en servir : rechercher_evenements avec les paramètres {"debut": "2026-11-02", "fin": "2026-11-06"}. La qualité des descriptions compte énormément : c’est uniquement à partir d’elles que le modèle décide quel outil utiliser et comment (exercice 4). Point essentiel pour la sécurité : c’est l’application, et non le modèle, qui exécute. Elle peut donc refuser une action, demander une confirmation à l’utilisateur ou limiter les paramètres autorisés.

3.3Les ingrédients d’un agent

  • Un modèle capable de planifier et d’utiliser des outils de façon fiable ; les modèles de raisonnement, qui réfléchissent longuement avant d’agir, sont souvent préférés pour les tâches longues.
  • Des outils, bien décrits, avec des droits aussi limités que possible.
  • Des instructions : la consigne système, invisible pour l’utilisateur, qui précise le rôle de l’agent, ses règles, ce qu’il doit faire en cas de doute.
  • Une mémoire : le contexte de la tâche en cours, et parfois des notes conservées d’une session à l’autre, par exemple un fichier où l’agent consigne ce qu’il a appris sur un projet.
  • Des garde-fous : confirmation humaine pour les actions sensibles, budget maximal de temps, d’étapes ou d’argent, environnement isolé, journal des actions.

3.4Flux de travail ou agent ?

Tous les systèmes qui combinent un modèle de langage et des outils ne sont pas des agents au sens strict. On distingue souvent les flux de travail (en anglais workflows), où le développeur fixe à l’avance l’enchaînement des étapes, et les agents, où le modèle décide lui-même de la suite. Un flux de travail est plus prévisible, moins coûteux et plus facile à tester ; un agent est plus souple face à des situations imprévues. Les praticiens recommandent de commencer par la solution la plus simple qui fonctionne, et de n’introduire de l’autonomie que lorsqu’elle apporte un gain réel (exercice 7).

Quelques schémas reviennent souvent. Le chaînage enchaîne des appels au modèle, chacun traitant le résultat du précédent : rédiger un plan, puis le texte, puis le traduire. Le routage oriente chaque demande vers le traitement adapté : une question de facturation vers un circuit, une réclamation vers un autre. La parallélisation lance plusieurs traitements en même temps, par exemple pour examiner un document sous plusieurs angles. Dans le schéma orchestrateur et exécutants, un modèle découpe la tâche en sous-tâches et les confie à d’autres instances, des sous-agents, avant de rassembler leurs résultats : c’est le principe des systèmes multi-agents. Enfin, dans la boucle évaluateur et optimiseur, un modèle produit un résultat qu’un autre critique, jusqu’à ce qu’il soit satisfaisant.

3.5Gérer la mémoire

Une tâche longue produit vite plus de texte que la fenêtre de contexte, la quantité maximale de texte qu’un modèle peut prendre en compte à la fois, ne peut en contenir : chaque fichier lu, chaque page consultée, chaque résultat de commande s’y ajoute. Les agents utilisent plusieurs techniques pour ne pas s’y perdre. La compaction remplace l’historique ancien par un résumé de ce qui a été fait et de ce qui reste à faire. Les notes écrites dans un fichier, une liste de tâches ou un journal de progression, permettent de reprendre le travail après une interruption, ou de le confier à une nouvelle session. Les sous-agents explorent une question dans leur propre contexte et ne renvoient que leur conclusion, ce qui évite d’encombrer celui de l’agent principal. Enfin, plutôt que de tout charger d’avance, un bon agent va chercher l’information au moment où il en a besoin, comme un humain qui ouvre un dossier plutôt que d’apprendre toutes les archives par cœur. La mémoire conservée d’une session à l’autre pose les mêmes questions que toute donnée stockée : que contient-elle, qui peut la lire, comment la corriger ou l’effacer ?

Pour s’exercer

Exercice 1 : l’accumulation des erreurs

Un agent réussit chaque étape d’une tâche avec une probabilité de 95 %, indépendamment des autres. Quelle est la probabilité qu’une tâche de 20 étapes se déroule sans aucune erreur ? Et si chaque étape réussit à 99 % ? Qu’en conclure ?

Voir la réponse

Il faut réussir les 20 étapes : 0,9520 ≈ 0,36, soit environ une chance sur trois. À 99 % par étape : 0,9920 ≈ 0,82. Une petite amélioration de la fiabilité de chaque étape change tout pour les tâches longues. Conclusion : un agent utile doit détecter et corriger ses erreurs en cours de route, par exemple en relançant les tests après chaque modification, et les tâches longues doivent comporter des points de contrôle. Le calcul est simplifié, car en réalité certaines erreurs sont rattrapables et d’autres non.

Exercice 2 : compter les intégrations

Une entreprise utilise 5 applications d’IA et veut les relier à 20 services internes. Combien d’intégrations faut-il développer sans standard commun ? Et avec le MCP ?

Voir la réponse

Sans standard, chaque application doit être reliée à chaque service : 5 × 20 = 100 intégrations, chacune à développer et à maintenir. Avec le MCP, chaque service est exposé une fois par un serveur, et chaque application implémente une fois le client : 20 + 5 = 25 composants, et un nouveau service devient immédiatement utilisable par toutes les applications. C’est le même raisonnement que pour les prises électriques ou l’USB : un standard transforme un problème multiplicatif en problème additif.

Exercice 3 : repérer la triade

Une entreprise déploie un agent qui lit les courriels entrants du service client, consulte les dossiers des clients dans le logiciel de gestion et peut envoyer des réponses. Quel risque ? Comment le réduire ?

Voir la réponse

Les trois ingrédients de la figure 3 sont réunis : des données privées, les dossiers des clients ; des contenus non fiables, les courriels écrits par n’importe qui ; un moyen de communiquer vers l’extérieur, l’envoi de réponses. Un courriel piégé pourrait demander à l’agent de joindre à sa réponse les données d’un autre client. Pour réduire le risque : limiter l’agent au dossier du client qui écrit, identifié par son adresse vérifiée ; faire relire et valider chaque réponse par un conseiller avant envoi, au moins tant que la confiance n’est pas établie ; interdire l’envoi à une adresse autre que celle de l’expéditeur ; journaliser et surveiller les réponses.

Exercice 4 : décrire un outil

Un développeur décrit ainsi un outil : nom del, description « supprime ». Pourquoi est-ce une mauvaise description ? Proposez mieux.

Voir la réponse

Le modèle ne sait ni ce qui est supprimé, ni dans quelles conditions utiliser l’outil, ni si l’action est réversible ; il risque de l’appeler à tort ou avec de mauvais paramètres. Mieux : nom supprimer_brouillon, description « Supprime définitivement un brouillon de courriel non envoyé, identifié par son numéro. Action irréversible : ne l’utiliser que si l’utilisateur a explicitement demandé la suppression de ce brouillon. Ne permet pas de supprimer des courriels envoyés ou reçus. », un seul paramètre, le numéro du brouillon. Et côté application, une confirmation de l’utilisateur avant exécution. Un bon outil fait une chose précise, porte un nom explicite et décrit ses effets et ses limites.

Exercice 5 : valider ou non ?

Classez ces actions d’un agent d’assistance administrative selon qu’elles peuvent être faites seules ou doivent être validées par un humain : (a) lire l’agenda ; (b) créer un brouillon de courriel ; (c) envoyer un courriel à un client ; (d) payer une facture fournisseur ; (e) supprimer un fichier ; (f) rechercher une information sur le Web.

Voir la réponse

Sans validation : (a), (b) et (f), qui ne modifient rien d’important ou sont facilement réversibles ; la recherche Web expose cependant l’agent à des contenus non fiables, ce qui compte s’il dispose par ailleurs d’actions sensibles. Avec validation : (c), qui engage l’entreprise et ne peut pas être annulé ; (d), qui engage de l’argent ; (e), sauf si une corbeille permet de restaurer le fichier. La règle : plus une action est irréversible, coûteuse ou visible de l’extérieur, plus la validation humaine s’impose.

Exercice 6 : le contexte qui grossit

Un agent accomplit une tâche en 10 tours de boucle. Au premier tour, le contexte envoyé au modèle compte 5 000 jetons ; chaque tour y ajoute 1 000 jetons, l’action et son résultat. Combien de jetons sont envoyés au modèle au total ?

Voir la réponse

Les tours envoient successivement 5 000, 6 000, 7 000… jusqu’à 14 000 jetons. La somme vaut 10 × 5 000 + 1 000 × (0 + 1 + … + 9) = 50 000 + 45 000 = 95 000 jetons, alors que le texte réellement nouveau ne représente que 15 000 jetons. Le coût croît donc plus vite que la longueur de la tâche. Les services d’IA réduisent cet effet par la mise en cache, qui facture moins cher la partie du contexte déjà envoyée ; les agents résument aussi leur historique quand il devient trop long.

Exercice 7 : flux de travail ou agent ?

Faut-il un flux de travail fixe ou un agent autonome pour : (a) traduire chaque nuit les nouvelles fiches produits ; (b) diagnostiquer pourquoi un site Web est devenu lent ; (c) classer les courriels entrants en quatre catégories ?

Voir la réponse

(a) Un flux de travail : les étapes sont toujours les mêmes, récupérer, traduire, vérifier, publier. (c) Un flux de travail aussi, et même un simple appel au modèle par courriel. (b) Un agent : on ne sait pas à l’avance quelles vérifications seront nécessaires, journaux, base de données, réseau, code récent, et chaque découverte oriente la suivante. Mieux vaut alors lui donner des droits en lecture seule et lui faire proposer les corrections plutôt que de les appliquer.