Agent ReAct : le pattern Thought, Action, Observation

Le pattern ReAct (Reasoning and Acting) est un patron de conception d'agents dans lequel un LLM alterne entre raisonner (Thought), appeler un outil (Action) et relire le résultat (Observation). Cette boucle se répète jusqu'à ce que l'agent produise une réponse finale. Il a été présenté par Yao et al. (arXiv:2210.03629, octobre 2022, ICLR 2023). Le raisonnement pilote le choix des outils, et les observations issues des outils corrigent le raisonnement.

• Ce que c'est : une boucle Thought, Action, Observation dans laquelle un LLM entrelace réflexion et action et utilise des outils dans le même contexte.
• À quoi ça sert : des tâches outillées, ancrées dans les faits, avec un historique entièrement traçable. ReAct est le point de départ standard des projets d'agents.
• Points de vigilance : boucles infinies, Reasoning Drift et arguments d'outils hallucinés ; à contenir avec des limites d'itération strictes et le function calling.

D'où vient ReAct et quel problème il résout

ReAct est né en réponse à deux faiblesses opposées des approches antérieures. Le Chain-of-Thought (CoT) pur raisonne exclusivement en interne et hallucine donc des faits, faute de tout ancrage dans le monde extérieur. À l'inverse, les agents purement orientés action, comme les premières approches WebGPT ou SayCan, ne savent pas raisonner de manière abstraite sur des objectifs à long terme ni se remettre d'exceptions.

ReAct réunit les deux : le raisonnement verbal se trouve dans le même contexte que les actions. Le LLM dispose ainsi d'une mémoire de travail sur toute la trajectoire, et l'agent devient interprétable. Formellement, ReAct élargit l'espace d'actions : en plus des actions externes, qui déclenchent de vraies observations, il existe des « actions » langagières (les Thoughts) qui ne modifient rien dans l'environnement et se contentent d'enrichir le contexte interne de l'agent. Fait notable : le pattern fonctionne déjà avec un ou deux exemples en contexte, sans fine-tuning.

La boucle en détail : Thought, Action, Observation

Le déroulement canonique est le suivant : User Query → [LLM: Thought] → [LLM: Action] → [Umgebung: Observation] → [LLM: Thought] → … → Finish[Antwort]. Les trois étapes s'enchaînent comme suit.

Ce cycle continue jusqu'à ce que le modèle émette Action: Finish[Antwort]. La limite pratique se situe le plus souvent à 10-25 étapes, avant que la perte de contexte ou le Reasoning Drift ne prennent le dessus.

Pseudo-code d'une boucle ReAct

1. context = systemPrompt + toolDescriptions + userQuery
2. schritt = 0
3. MAX_SCHRITTE = 15 # hartes Limit gegen Endlos-Loops
4. while schritt < MAX_SCHRITTE:
5. ausgabe = LLM(context) # erzeugt Thought + Action
6. if ausgabe.action == "Finish":
7. return ausgabe.action.argument # finale Antwort
8. observation = führeToolAus(ausgabe.action) # externer Call
9. context = context + ausgabe.thought + ausgabe.action + observation # Beobachtung anhängen
10. schritt += 1
11. return "Limit erreicht, keine Lösung gefunden." # sauberer Abbruch

Point central : à chaque itération, l'intégralité de l'historique est renvoyée au LLM. C'est à la fois la source de sa force (mémoire complète) et de sa principale faiblesse (coût).

Forces et limites selon la recherche

L'article original démontre les avantages de ReAct sur plusieurs benchmarks. Important : les chiffres proviennent des conditions de 2022/2023 (modèles de la classe GPT-3 et PaLM) et doivent être lus comme des valeurs relatives, pas comme des valeurs absolues actuelles.

• ALFWorld (tâches ménagères textuelles) : +34 points de pourcentage absolus par rapport aux baselines d'imitation/RL, avec un ou deux exemples.
• WebShop (navigation e-commerce) : +10 points de pourcentage absolus de taux de réussite par rapport à IL/IL+RL.
• HotpotQA et Fever : compétitif, voire meilleur que le CoT pur ou la génération d'actions pure ; la configuration la plus performante est un hybride qui bascule entre connaissances internes et raisonnement outillé.

Côté coûts, ReAct est cher et lent. La consommation de tokens croît en O(N · T) : N étapes multipliées par la longueur cumulée du contexte, car chaque étape repaie le préfixe (prompt système, descriptions des outils, historique complet). La latence est strictement séquentielle, soit environ N × (temps de réponse du LLM + temps de réponse de l'outil). C'est précisément cette répétition du préfixe que le pattern successeur ReWOO traite avec seulement deux appels au LLM.

Modes de défaillance et contre-mesures

Trois modes de défaillance reviennent particulièrement souvent en pratique :

• Boucles infinies : sans limite stricte du nombre d'étapes, l'agent peut raisonner en rond indéfiniment. Contre-mesure : des limites explicites, par exemple recursion_limit dans LangGraph, max_tool_iterations sur l'AssistantAgent dans AutoGen (ou bien une condition d'arrêt comme MaxMessageTermination), max_iter dans CrewAI. Le create_react_agent de LangGraph propose un canal remaining_steps et s'arrête avec un message d'avertissement lorsqu'il reste moins de deux étapes.
• Reasoning Drift / propagation des erreurs : une fois que le modèle s'est fixé sur un Thought erroné, il interprète les Observations suivantes de manière à ce qu'elles collent avec lui. Contre-mesure : trajectoires plus courtes, validation intermédiaire et, pour les tâches vérifiables, un signal externe de réflexion/vérification (passerelle vers le pattern Reflexion).
• Arguments d'outils hallucinés et observations hallucinées : face à des descriptions d'outils ambiguës, le modèle invente des arguments ; les modèles plus faibles « fantasment » parfois aussi des observations au lieu d'attendre le vrai résultat de l'outil. Selon la recherche, les arguments d'outils JSON malformés sont l'erreur de production la plus fréquente sur les modèles plus faibles. Contre-mesure : utiliser la sortie structurée ou le mode function calling chaque fois que le fournisseur le prend en charge, et rédiger des descriptions d'outils précises.

S'y ajoute l'inflation du contexte déjà évoquée : chaque étape renvoie l'historique complet.

Exemple concret : un agent de recherche pour une agence marketing

Imaginons qu'une agence construise un agent chargé de trouver l'effectif actuel d'une entreprise cliente. La boucle pourrait se dérouler ainsi :

1. Thought : « Je ne connais pas le chiffre actuel et je dois le chercher. » → Action : Suche["Mitarbeiterzahl Firma X 2026"] → Observation : un résultat avec un communiqué de presse.
2. Thought : « Le communiqué donne une fourchette, il me faut le chiffre exact. » → Action : Öffne[URL der Pressemeldung] → Observation : texte intégral avec « environ 1 200 salariés ».
3. Thought : « Cela répond à la question. » → Action : Finish["ca. 1.200 Mitarbeiter, Stand 2026"].

Trois étapes, trois appels au LLM, un historique entièrement journalisé. Avec MAX_SCHRITTE = 15, l'agent est protégé contre les boucles infinies. S'il ne trouve rien, il s'arrête proprement au lieu de brûler des tokens. C'est précisément ce déroulement traçable qui constitue un avantage réel pour les équipes marketing sans profil de développeur : dans n8n, par exemple, la vue d'exécution affiche chaque appel au LLM et aux outils sous forme de log auditable.

Frameworks et recommandations pratiques (état 2026)

ReAct est disponible nativement dans toutes les stacks courantes : LangGraph (create_react_agent), CrewAI (chaque agent est en interne un agent ReAct), AutoGen ou le Microsoft Agent Framework (en 2026, AutoGen est en mode maintenance ; Microsoft oriente les nouveaux projets vers l'Agent Framework) et n8n. Le nœud AI Agent y implémente la boucle raisonnement-action depuis n8n 1.82.0 en tant que Tools Agent via function calling natif ; la sélection d'un type d'agent ReAct dédié est marquée comme obsolète. Chez LangChain, create_react_agent migre en 2026 de langgraph.prebuilt vers langchain.agents.create_agent avec des décorateurs de middleware.

L'enseignement pratique le plus important vient d'Anthropic (« Building Effective Agents », décembre 2024) et de Cognition : commencer par le pattern le plus simple, le plus souvent ReAct, et ne monter en complexité que lorsque des modes de défaillance mesurés l'imposent. Les modèles frontières modernes maîtrisent nativement la boucle raisonnement-action via le function calling ; un prompting ReAct explicite est souvent superflu. Ce qui compte alors, ce sont la mémoire, les plafonds d'itération et le tracing. Les outils d'observabilité (LangSmith, Arize Phoenix, Langfuse) font pratiquement partie du socle en production. Le règlement européen sur l'IA impose une journalisation automatique pour les systèmes d'IA à haut risque (article 12 du règlement sur l'IA) ; les agents de marketing et de recherche typiques n'en relèvent généralement pas. Une trace persistée reste utile, pour le débogage et la traçabilité. Si elle contient des données personnelles, la minimisation des données et la limitation de la conservation s'appliquent au titre de l'article 5 du RGPD : nettoyer les PII et fixer un délai de suppression.

Pour les agences et les décideurs B2B

ReAct est le point d'entrée pragmatique pour presque tout projet d'agent : chatbots clients connectés au CRM et à la base de connaissances, tri des tickets de support ou tâches de recherche. Il se met en place rapidement et reste entièrement auditable, deux atouts qui comptent dans le B2B en Europe. Mais les coûts et la latence augmentent à chaque étape. Fixe donc dès le départ des limites d'itération strictes, utilise le function calling plutôt que des arguments en texte libre et conserve la trace pour l'audit et le débogage. Si, en tant qu'agence, tu veux concevoir un agent ou faire vérifier la stabilité d'un workflow existant, contacte-nous. Nous t'accompagnons dans le choix, l'architecture et une mise en œuvre conforme aux exigences réglementaires.