Architecture d'agent React : modèles, pièges, correctifs

Essentiel du pattern

ReAct (Reasoning + Acting) est un pattern qui permet à un agent d'agir étape par étape, en prenant une décision après chaque action selon le résultat obtenu.

Quand l'utiliser : quand il est impossible de planifier de façon fiable tout le parcours à l'avance, et que l'étape suivante dépend du résultat précédent.

Chaque étape se compose de trois actions :

• Think — décide quoi faire ensuite
• Act — exécute une action ou appelle un outil
• Observe — analyse le résultat

Ensuite, l'agent décide à nouveau de l'étape suivante.

Problème

Imagine : tu es dans une nouvelle ville pour la première fois et tu cherches une pharmacie ouverte avec le médicament dont tu as besoin.

Tu ne sais pas à l'avance :

• quelles pharmacies sont à proximité
• si elles sont ouvertes maintenant
• si le médicament est disponible

Il est impossible de construire un plan complet immédiatement, parce que chaque étape dépend d'un nouveau résultat.

Donc tu agis en boucle :

1. Tu trouves la pharmacie la plus proche
2. Tu vérifies si elle est ouverte
3. Si non, tu passes à la suivante
4. Tu répètes jusqu'à trouver la bonne

Autrement dit en continu : information -> décision -> action -> nouvelle information.

Et si tu te forces à figer l'itinéraire tout de suite ("#1 -> #2 -> #3"), ce sera un plan au hasard.

Voilà le problème : dans beaucoup de tâches, il est impossible de planifier correctement toutes les étapes à l'avance.

Solution

ReAct résout cela avec des décisions pendant l'exécution, et non avec un plan rigide défini à l'avance.

Analogie : c'est comme un GPS sur la route. Tu construis la prochaine manœuvre après chaque nouveau virage ou route bloquée. L'itinéraire se précise en cours de route, il n'est pas figé une fois pour toutes.

Principe clé : un plan complet n'est pas possible immédiatement, donc l'agent doit s'adapter après chaque résultat.

Au lieu de plan complet d'abord -> exécution ensuite, l'agent fonctionne ainsi :

1. Raisonnement (Think) : prend une décision
2. Action (Act) : exécute une action
3. Observation (Observe) : analyse le résultat

Après cela, il définit l'étape suivante selon le nouveau contexte.

Si une pharmacie est fermée, l'agent ne "force" pas l'ancien plan, il ajuste les actions immédiatement.

Chaque nouveau résultat :

• est ajouté au contexte
• influence la décision suivante
• modifie l'itinéraire à venir

ReAct n'exécute pas un script prédéfini, il s'adapte à chaque étape.

Le modèle peut "vouloir" répéter des actions à l'infini, donc c'est la politique d'exécution (execution-policy) qui définit les conditions d'arrêt de la boucle.

Comment ça fonctionne

Important : l'agent n'exécute pas lui-même les actions

À l'étape raisonnement (Think), l'agent décide seulement de ce qu'il faut faire ensuite.

Mais il n'exécute pas l'action lui-même.

Il génère une décision sous forme de texte, par exemple :

« Il faut appeler l'outil search_docs avec le paramètre X »

Après cela :

• le système autour de l'agent lit cette décision
• exécute l'action ou appelle l'outil
• renvoie le résultat

Ce résultat devient une nouvelle observation (Observe).

Si cette couche n'a pas de limites, l'agent peut :

• appeler un outil des dizaines de fois
• répéter les mêmes actions
• consommer le budget en appels API

La boucle se répète jusqu'à ce que la tâche soit terminée ou que les conditions d'arrêt soient atteintes.

En code, cela ressemble à ça

max_steps = 8

for step_no in range(1, max_steps + 1):
    thought = think(context)
    action = act(thought)
    result = observe(action)

    context.append(result)  # Observe -> nouveau context pour le Think suivant.

    if is_done(result):
        done = True
        break

if not done:
    return stop_with_reason("max_steps_reached")

À quoi cela ressemble pendant l'exécution

Goal: trouver la pharmacie ouverte la plus proche

Think: il faut trouver une pharmacie à proximité
Act: le système appelle find_nearby_pharmacies(user_location)
Observe: liste de pharmacies reçue, triée par distance
Entre les itérations : la liste des pharmacies est ajoutée au context

Think: vérifier la première pharmacie (la plus proche)
Act: le système appelle check_pharmacy("Pharmacie #1")
Observe: la pharmacie est fermée
Entre les itérations : le statut "fermée" est ajouté au context

Think: vérifier la pharmacie suivante
Act: le système appelle check_pharmacy("Pharmacie #2")
Observe: la pharmacie est ouverte

Think: c'est la pharmacie ouverte la plus proche
Act: le système renvoie l'adresse
Observe: l'utilisateur a reçu le résultat
Stop : condition atteinte, la boucle se termine

L'agent décide quoi faire, exécute une action et obtient un résultat.

Chaque résultat est ajouté au contexte et devient la base de l'étape suivante.

Quand c'est adapté - et quand ça ne l'est pas

Adapté

Non adapté

Si tu choisis ReAct, fixe les limites dès le départ : max_steps, timeouts, conditions d'arrêt et budget des appels d'outils.

Quand utiliser ReAct (vs autres patterns)

Utilisez ReAct quand l'agent doit prendre des décisions étape par étape selon les résultats des actions précédentes.

Test rapide :

• si vous avez besoin de "j'ai vu le résultat -> j'ai décidé l'étape suivante" -> ReAct
• si vous avez besoin de "d'abord découper un grand objectif en sous-tâches" -> Task Decomposition Agent

Comment combiner avec d'autres patterns

ReAct est souvent utilisé avec d'autres patterns.

• ReAct + RAG — quand il manque des faits, l'agent les récupère d'abord depuis la base de connaissances, puis seulement avance.
• ReAct + Reflection — après chaque étape, l'agent s'auto-vérifie pour repérer et corriger vite les erreurs.
• ReAct + Supervisor — l'agent n'exécute pas lui-même les actions risquées ; il les transmet pour validation humaine.

ReAct ajoute une boucle de décision. Les autres patterns ajoutent du contrôle, de la mémoire ou de la coordination.

En bref

Avantages et Inconvénients

FAQ

Q : Est-ce que ReAct planifie toutes les étapes à l'avance ?
A : Non. Il prend une décision après chaque action.

Q : Est-ce que ReAct peut rester bloqué dans une boucle ?
A : Oui, si aucune condition d'arrêt n'est définie.

Q : Est-ce que ReAct fonctionne sans outils ?
A : Oui. L'agent peut utiliser la boucle Think -> Act -> Observe même sans appel d'outil, par exemple pour changer d'approche sur une tâche. Mais sans accès à des actions externes, il ne peut pas obtenir de nouvelles données et travaille uniquement avec ce qui est déjà dans le contexte.

Et ensuite

ReAct permet à un agent d'agir étape par étape.

Mais que faire si la tâche est complexe et composée de plusieurs sous-tâches ?