#boucle-agentique — IA agentique

Boucle ReAct d'un agent : Pensée → Action → Observation en direct.

Ce que tu vas manipuler

Bienvenue dans #boucle-agentique. Un agent, ce n'est pas un LLM qui répond, c'est un LLM qu'on fait tourner en boucle : Pensée → Action (appel d'outil) → Observation (retour de l'outil) → nouvelle Pensée, jusqu'à pouvoir répondre. C'est la boucle ReAct. Au centre, le LLM (grosse bulle) ; autour, six outils qu'il peut appeler (fichier, calcul, web, shell, base, recherche). Tu vas la faire tourner au ralenti, un pas à la fois.
Fixe un objectif à l'agent. Le scénario par défaut : lire config.json et rendre son contenu. Tape /objectif Lis config.json et rends son contenu — ou laisse celui par défaut et passe à l'étape suivante.
Un pas. Tape /pas : le LLM va penser (le bandeau devient rose), pas encore agir. C'est cette étape de raisonnement explicite qui rend l'agent robuste — sans elle, il enchaîne des actions à l'aveugle.
Encore /pas. Cette fois l'agent agit : un rayon part du LLM vers l'outil fichier, l'outil s'allume, et le tuteur affiche l'appel exact (nom d'outil + arguments).
/pas encore. L'outil renvoie son résultat : c'est l'Observation. Un rayon revient de l'outil vers le LLM, la bulle centrale intègre l'info, et le tuteur t'affiche le JSON reçu.
Plutôt que d'égrainer, lance la boucle jusqu'au bout : /tourner. Tu vas voir l'agent alterner Pensées et Actions jusqu'à produire une Réponse finale (bandeau vert).
Un scénario plus riche : /scenario multi. L'agent doit lire un fichier, compter les mots, chercher un mot-clé en ligne. Regarde comme il enchaîne trois outils différents.
Relance : /tourner. Compte les itérations, regarde quels outils s'allument, quelles observations reviennent.
À toi. Essaie /scenario calcul puis /tourner (arithmétique en deux temps), ou /max 3 puis /scenario multi et /tourner pour voir un échec par plafond d'itérations. Ensuite, #outils-appel (function calling, MCP — gratuit) détaille la mécanique d'un appel ; les canaux Premium #slash-commands (Claude Code / Cursor), #planification-reflexion et #multi-agents montent d'un cran chacun.

Commandes du canal

/objectif <texte> — Fixe l'objectif que l'agent doit atteindre.
/scenario <recherche|calcul|multi> — Charge un scénario prêt à l'emploi (trace déterministe).
/pas — Avance d'un événement (Pensée, Action ou Observation).
/tourner — Fait boucler l'agent jusqu'à la réponse (ou l'échec).
/max <n=3..15> — Fixe le plafond d'itérations (garde-fou anti-boucle).
/reinit — Remet la boucle à zéro (le scénario courant reste).

Glossaire

boucle ReAct: Motif d'orchestration où le LLM alterne Pensées (raisonnement en langue naturelle) et Actions (appels d'outils), chaque action retournant une Observation qui alimente la Pensée suivante. Base commune à Claude Code, Cursor, LangChain, AutoGen — l'article fondateur est ReAct: Synergizing Reasoning and Acting in Language Models (Yao et al., 2023).
appel d'outil: Le LLM émet un JSON structuré qui nomme un outil (fonction) et ses arguments. Le runtime exécute réellement la fonction et renvoie le résultat au LLM sous forme d'observation. Standardisé côté OpenAI (tools), Anthropic (tool use) et par le protocole ouvert MCP.
observation: Retour d'un outil (chaîne, JSON, erreur) que le LLM relit à l'itération suivante. Souvent tronquée pour tenir dans la fenêtre de contexte — c'est là qu'un canal comme #contexte-memoire (Premium) devient précieux.
itération: Une passe Pensée → Action → Observation. Un agent utile fait 3 à 20 itérations selon la tâche. Un plafond max est indispensable pour éviter les boucles infinies (l'agent qui répète la même action ou se perd en Pensées).
MCP: Protocole ouvert (Anthropic, 2024) qui standardise comment un LLM appelle des outils exposés par un serveur — fichiers, git, base de données, web… Cursor, Claude Code et Claude Desktop consomment tous des serveurs MCP. Détaillé dans #outils-appel (gratuit) et #slash-commands (Premium).
slash command: Raccourci de type /plan, /review, /test qui déclenche un prompt pré-écrit ou un mini-workflow d'agent. Claude Code et Cursor en fournissent des natifs et laissent l'utilisateur en définir. Le canal #slash-commands (Premium) montre comment les concevoir et les enchaîner.
plafond d'itérations: Nombre maximum de tours autorisés avant d'interrompre l'agent. C'est le garde-fou minimum en production : un agent qui boucle coûte cher (chaque tour = 1 appel LLM) et rend une réponse à l'utilisateur qui attend. Tape /max 3 puis /scenario multi pour le voir déclencher.
trace: Historique complet Pensées + Actions + Observations d'un run. Indispensable pour déboguer (comprendre pourquoi l'agent a pris tel chemin) et pour l'observabilité en prod (LangSmith, Braintrust, Arize…).

Autres canaux du thème IA agentique

#boucle-agentique — Boucle ReAct d'un agent : Pensée → Action → Observation en direct.
#outils-appel — Appel d'outil (function calling / MCP) : le JSON qui fait agir le LLM.
#slash-commands — Slash commands à la Claude Code / Cursor : templates, arguments, enchaînement.
#contexte-memoire — Fenêtre de contexte et mémoire d'agent : compter, tronquer, résumer, indexer.
#planification-reflexion — Planification, réflexion et self-correction : de 60 % à 90 % de succès.
#multi-agents — Multi-agents : planner, workers, verifier. Un DAG qui bat l'agent monolithique.