04

Agents & MCP

Ce qu’un agent fait, et ce qu’il ne fait pas

Module 049 min de lectureMis à jour le 20 novembre 2026

Un agent n’est pas un chatbot avec des boutons. C’est une boucle qui observe un état, choisit une action, l’exécute, puis regarde le résultat. Cette boucle est puissante quand le chemin n’est pas connu à l’avance, et coûteuse quand une règle simple suffisait.

Nous allons voir où placer les garde-fous, comment un serveur MCP expose des outils, pourquoi la mémoire longue accumule les erreurs, et comment évaluer un agent sans se raconter d’histoires. Le module se termine par les topologies de flotte et les méthodes qui tiennent en production.

Une analogie utile :
Une IA classique (ChatGPT) est un Encyclopédiste paralysé dans un bocal. Il sait tout, mais ne peut rien toucher.
Un Agent IA est ce même encyclopédiste à qui on a greffé des bras (Tools) et donné un accès internet.

🧠 La mécanique de base

Agent = LLM + Tools + ReAct Loop

ReAct (Reasoning + Acting) est la boucle, bornée par un nombre max d’itérations :

  1. OBSERVE : "L’utilisateur veut la météo."
  2. REASON : "Je ne connais pas la météo. J’ai un outil météo."
  3. ACT : "J’appelle `get_weather(Paris)`."
  4. OBSERVE : "L’outil a répondu 15°C."
  5. ACT : "Je réponds à l’utilisateur."

🤖 Les Types d’Agents

Single Agent
Un seul cerveau avec plusieurs outils (ex: Le bot Support Client).
Multi-Agent (Swarm)
Une équipe de spécialistes. Un "Manager" délègue à un "Coder", un "Reviewer" et un "Designer".
Outils : CrewAI, AutoGen, LangGraph.

La boucle ReAct échoue de trois manières prévisibles. L’agent peut inventer un outil qui n’existe pas, appeler le bon outil avec de mauvais arguments, ou tourner en rond parce que le résultat ne correspond pas à ce qu’il attendait. Elle coûte aussi de l’argent à chaque tour : chaque observation et chaque raisonnement repartent dans le contexte. C’est pourquoi une règle déterministe ou un workflow n8n classique reste souvent préférable pour une tâche connue. L’agent est intéressant quand le chemin doit être découvert, pas quand il est déjà écrit.

Le Standard MCP (Model Context Protocol)

MCP ressemble à un connecteur standard : il décrit les outils et le transport entre un hôte et un serveur. Avant, chaque connexion demandait son propre code. MCP réduit ce travail, mais ne garantit ni la qualité de l’outil, ni la sécurité des données qu’il expose.

Host (L’Hôte)

L’application où vous chattez (Claude Desktop, Cursor, n8n).

Server (L’Outil)

Le connecteur qui "parle" à la donnée (Google Drive MCP, Slack MCP, GitHub MCP).

Client

Le connecteur local qui relie l’hôte au serveur (transport STDIO ou HTTP).

MCP standardise le transport et la description des outils, pas la confiance. Un serveur MCP peut exposer un outil qui lit vos fichiers, envoie des emails ou modifie une base. Il faut donc décider quels serveurs sont autorisés, quels outils sont accessibles, avec quels identifiants, et ce que l’agent fait du résultat. Une réponse d’outil est une donnée non fiable : elle peut contenir une instruction injectée. Le modèle ne doit pas confondre le contenu d’un document avec un ordre.

🆚 Trois façons de connecter

  • API (Classique) :
    Complexe. Demande d’apprendre la doc par cœur. Code manuel.
  • Webhook :
    Passif. "Si X arrive, fais Y". L’IA subit l’événement, elle ne peut pas "chercher".
  • MCP (Agentic) :
    Actif & Découvrable. L’outil dit "Hey, je sais envoyer des mails !". L’IA répond "Cool, je t’utiliserai si besoin".

Vocabulaire Agentique

Le critère de choix n’est pas la mode, c’est la variabilité de la tâche. Si vous pouvez dessiner le chemin sur une feuille, un workflow déterministe sera plus simple à tester, à auditer et à réparer. Si le chemin change à chaque demande, qu’il faut chercher dans plusieurs sources et décider quoi faire ensuite, un agent peut aider. Entre les deux, le semi-IA consiste à laisser le modèle proposer et à garder une règle ou un humain pour disposer.

Quel pilotage pour quel besoin ?

100 % déterministe : même entrée, même sortie, toujours. Paie, facturation, conformité : aucune IA sur le chemin critique. Voir modules 3 et 14.
Semi-IA (le réglage recommandé) : l’IA propose, une règle ou un humain dispose. Un nœud de validation bloque toute action irréversible (paiement, suppression, envoi client). Voir module 3.
Full-IA supervisé : l’agent tourne seul mais en sandbox, avec budget tokens et journal d’actions relu a posteriori. Jamais d’écriture irréversible sans filet. Voir module 1 (les harnais en local).

Le harnais : ce qui transforme un modèle en agent

Un modèle seul répond. Le harnais lui donne une boucle, des outils, du contexte, une mémoire, des permissions et un budget. À modèle égal, deux harnais ne produisent pas les mêmes résultats : c’est pourquoi les comparaisons sérieuses de 2026 portent sur le couple modèle et harnais, pas sur le modèle isolé.

Boucle bornée

Un nombre de tours maximal, un budget de tokens et une limite de temps. Sans borne, un agent qui échoue tourne jusqu’à la facture.

Contexte

Ce qui entre dans la fenêtre : consigne, documents, résultats d’outils. On le compresse au lieu de l’empiler.

Outils

Schéma typé, idempotence, mode simulation. Un outil qui écrit doit pouvoir être rejoué sans doubler l’effet.

Mémoire

Session courte, mémoire longue, skills. La mémoire longue se relit et se corrige, sinon elle accumule les erreurs.

Permissions

Sandbox, liste d’autorisation, approbation humaine sur toute action irréversible. Le droit d’agir se donne outil par outil.

Trace

Chaque tour journalisé : entrée, décision, outil, sortie, coût. Rejouable pour l’audit et pour la mise au point.

boucle_bornee.txt
tour = 0
tant que tour < 8 :
    action = modele.decide(contexte, outils)
    si action.type == "reponse"      -> sortir
    si action.outil est sensible     -> demander approbation
    resultat = outil.executer(action)
    contexte = compresser(contexte + resultat)
    tour = tour + 1
sinon                                -> escalader a un humain
Le harnais est un produit, pas un script : gardez le modèle derrière une interface. Changer de fournisseur doit être une ligne de configuration, pas une réécriture de la boucle. C’est ce qui rend une flotte durable quand les prix bougent.

Flottes d’agents : quatre topologies, un seul critère

Le multi-agent est souvent vendu comme un essaim. En pratique, quatre topologies couvrent le besoin. Le critère de choix est simple : chaque saut entre deux agents ajoute des tokens, de la latence et un point de panne. On n’ajoute un agent que si le découpage apporte une compétence ou une permission différente.

Superviseur

Un agent chef découpe la demande, délègue à des spécialistes, puis agrège. Bon pour un livrable unique et long.

Risque : le chef résume l’état de ses sous-agents au lieu de le vérifier.

Routeur

Une décision oriente vers un spécialiste, sans retour. Bon pour le support, le tri, la priorisation.

Risque : une mauvaise route produit une bonne réponse à la mauvaise question.

Pipeline

Des étages séquentiels avec un contrat d’entrée et de sortie. Bon pour la production : chaque étage se teste seul.

Risque : rigide quand la demande sort du chemin prévu.

Essaim

Des agents pairs qui se parlent jusqu’à converger. Bon pour explorer, coûteux et difficile à auditer en production.

Risque : la conversation tourne sans qu’aucun agent ne tranche.

Runtimes libres pour tenir une flotte

Hermes Agent (MIT)

Le runtime de Nous Research : boucle qui apprend, skills créés après une tâche complexe, sous-agents, tâches planifiées, passerelle Telegram, Discord, Slack, WhatsApp, Signal et email.

Six backends de terminal : local, Docker, SSH, Modal, Daytona, Vercel Sandbox. MCP intégré. Plus de 260 000 étoiles au 10 novembre 2026.

OpenMausBot (Apache 2.0)

Une alternative libre avec une machine virtuelle par bot : l’agent agit dans un environnement jetable, pas sur votre poste.

TypeScript et Electron, auto-hébergé, orienté computer use. Environ 20 500 étoiles au 10 novembre 2026.

Et en visuel ? Les agents n8n (module 3) couvrent le besoin sans code : un modèle, des instructions, des outils, des approbations et un journal. Pour une flotte de plus de trois agents, le runtime dédié reste plus lisible qu’un canvas.

Six méthodes qui séparent un prototype d’un système

Spec-driven

Écrire la spécification et les critères d’acceptation avant de générer. Sans critère, on évalue au feeling.

Eval-driven

Dix à cinquante cas de test avant de toucher au prompt. Chaque régression observée devient un test permanent.

Context engineering

Choisir ce qui entre dans la fenêtre. Un contexte propre bat un prompt astucieux chargé de bruit.

RAG ou fine-tuning

RAG pour la connaissance qui bouge et les sources citables. Fine-tuning pour le style et le format stables.

Observabilité

Trace, coût par exécution, taux d’escalade, taux d’échec par outil. Sans mesure, pas d’amélioration.

Garde-fous

Validation de sortie, plafond de dépense, approbation, coupe-circuit. Un garde-fou se teste en le déclenchant.

Ordre de mise en œuvre : 1. une règle écrite si elle suffit, 2. du RAG pour la connaissance, 3. un petit modèle dédié pour les décisions, 4. le fine-tuning en dernier, car c’est le plus cher à maintenir. La plupart des projets s’arrêtent à l’étape 2 et s’en portent bien.
TP

Atelier Pratique

Objectif : Agent Interne

Créer un workflow n8n qui reçoit une demande, active un Agent IA, qui consulte un outil via MCP (Brave Search) et répond.

Trigger (Webhook) -> OpenAI (Tool Calling) -> Router -> MCP Client -> OpenAI (Synthèse) -> Response
XP

Mise en pratique : MCP et n8n

Le "Bridge" (Pour Claude)

Exposer vos workflows n8n comme des outils locaux pour Claude Desktop, via un serveur MCP communautaire. Aucun paquet officiel n’existe sous ce nom : vérifiez le paquet actif au moment de l’atelier.

Webhook n8n -> Serveur MCP -> Claude Desktop

Le Schema Sticky Note

Décrivez vos outils directement dans le canvas n8n pour que le Bridge les détecte.

@mcp-tool: search_client inputSchema: { "email": "string" }

Serveur MCP minimal : 15 lignes qui exposent un outil

Exemple Python avec le SDK officiel (paquet mcp). Ce serveur expose une recherche client à n’importe quel client MCP (Claude Desktop, Cursor, n8n).

serveur_mcp.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("clients")

@mcp.tool()
def chercher_client(email: str) -> str:
    """Retrouve un client par son email."""
    return "Client " + email + " : statut VIP, 12 commandes."

if __name__ == "__main__":
    mcp.run()

Function Calling

Le modèle appelle VOS fonctions, décrites en schéma JSON. Vous codez tout, couplage fort au modèle.

MCP

Le modèle découvre des OUTILS externes standardisés. Un serveur, tous les clients compatibles.

A2A (Agent2Agent)

Des AGENTS qui dialoguent entre eux (protocole de Google). Utile en essaim, overkill pour exposer un simple outil.

Repère 2026 : en local le transport STDIO domine, en distant c’est le HTTP streamable. Vérifiez la doc de votre client avant l’atelier, ça bouge vite.