🔁 Épisode 1 · Un modèle qui répond, un agent qui agit

Un LLM ne fait toujours
qu'une seule chose : prédire le prochain token.

Un agent n'est pas un nouveau type de modèle. C'est le même LLM, appelé plusieurs fois de suite dans une boucle — en lui donnant à chaque fois un peu plus de contexte, jusqu'à ce qu'il ait assez d'information pour répondre.

🎯 L'analogie clé

Un détective ne résout pas une enquête en un seul éclair de génie. Il observe un indice, en déduit une hypothèse, va vérifier cette hypothèse sur le terrain, note ce qu'il trouve, et recommence — jusqu'à avoir assez d'éléments pour conclure. Chaque nouvelle observation vient s'ajouter à son carnet de notes, qu'il relit avant chaque nouvelle déduction.

Le cycle ReAct

Penser → Agir → Observer → recommencer.

ReAct (Reasoning + Acting) formalise ce cycle. À chaque tour, le modèle reçoit tout ce qui s'est passé avant, et produit soit une nouvelle pensée, soit une action à exécuter.

💭

Thought

Le modèle génère du texte de raisonnement : que sait-on, que manque-t-il, quelle est la prochaine étape logique. C'est du texte ordinaire, généré token par token comme n'importe quelle réponse.

⚙️

Action

Le modèle génère un appel d'outil structuré (nom de fonction + arguments). Un programme, à l'extérieur du modèle, exécute réellement cette action.

👁️

Observation

Le résultat de l'outil est réinjecté dans le contexte, comme s'il avait été écrit par le modèle lui-même. Le prochain appel du modèle voit tout l'historique, y compris ce résultat.

Le point clé : il n'y a pas de mémoire séparée ni de module de décision distinct. Chaque étape est un appel normal au LLM (exactement le mécanisme de l'épisode 6 de la série LLM), sur un contexte qui a simplement grandi d'une étape à l'autre.

À vous de manipuler

Faites tourner la boucle,
étape par étape.

Question posée à l'agent : « Quelle température fait-il à Paris, en Fahrenheit ? » L'agent ne connaît ni la météo ni la formule de conversion à l'avance — il doit utiliser deux outils. Avance étape par étape et regarde le contexte grandir réellement, comme un vrai historique de conversation envoyé au modèle à chaque appel.

Boucle ReAct — résoudre « température à Paris en °F »

La barre montre la taille du contexte (en tokens estimés) que le modèle doit relire à chaque appel — elle ne fait que grandir, jamais diminuer, tant que la boucle continue.

Étape

0 / 8

Appels au LLM

Outils exécutés

Contexte estimé

0 tokens

Observez : résoudre cette question en 2 outils a nécessité 4 appels au LLM (Thought, Action, Thought, Action — les Observations viennent des outils, pas du modèle), et le contexte a presque sextuplé entre la première et la dernière étape. Sur une tâche à 20 étapes, ce même mécanisme peut faire exploser le contexte bien plus vite que linéairement en coût réel de calcul.

Ce que la boucle ne résout pas

Plus d'étapes, plus d'occasions de dérailler.

Chaque Thought et chaque Action est une prédiction — donc une occasion de se tromper : mauvais outil choisi, mauvais argument, mauvaise interprétation de l'observation. Ce sujet est développé en détail dans un épisode dédié plus loin dans la série.

🎯

Mauvais choix d'outil

Le modèle peut appeler un outil qui n'est pas pertinent, ou halluciner un outil qui n'existe pas — le même phénomène qu'à l'épisode 12 de la série LLM, appliqué au choix d'une action plutôt qu'à un fait.

🔁

Boucles infinies

Sans limite explicite, un agent peut répéter indéfiniment la même action sans jamais converger — d'où l'importance pratique d'un nombre maximal d'étapes.

📉

Contexte saturé

Passé un certain nombre d'étapes, le contexte devient si long que le modèle « perd » des détails des premières observations — d'où le rôle de la mémoire externe, vue au prochain épisode.

Python (idée)

# La boucle ReAct, réduite à l'essentiel

context = ["Question : quelle température à Paris, en Fahrenheit ?"]

for step in range(MAX_STEPS):
    reponse = llm.generate("\n".join(context))   # même appel qu'un chatbot classique

    if reponse.type == "action":
        resultat = executer_outil(reponse.outil, reponse.arguments)
        context.append(f"Action: {reponse}")
        context.append(f"Observation: {resultat}")   # le contexte grandit
    elif reponse.type == "final_answer":
        break                                       # la boucle s'arrête

Vérifiez votre compréhension

Quiz rapide.

Dans la boucle ReAct, qu'est-ce qui différencie fondamentalement un agent d'un simple chatbot ?

À retenir

Un agent n'est pas un modèle différent : c'est le même LLM, appelé plusieurs fois dans une boucle Thought → Action → Observation.
Chaque étape de la boucle est un appel de génération ordinaire (épisode 6 de la série LLM) sur un contexte qui a grandi d'une étape à l'autre.
Les résultats d'outils (Observations) sont réinjectés tels quels dans le contexte — le modèle ne « sait » rien qu'il n'a pas vu dans ce texte.
Le contexte ne fait que croître au fil de la boucle, jamais diminuer — ce qui a un coût de calcul et une limite pratique (la fenêtre de contexte du modèle).
Chaque étape est une prédiction, donc une occasion d'erreur : mauvais outil, mauvais argument, boucle qui ne converge pas.

ÉPISODE SUIVANT

Function Calling : comment un LLM choisit un outil

À chaque étape de la boucle, le modèle doit choisir parmi plusieurs outils disponibles. Ce choix n'est ni magique ni séparé du modèle : c'est encore une distribution de probabilité, comme à l'épisode 7 de la série LLM.

Un LLM ne fait toujoursqu'une seule chose : prédire le prochain token.

Penser → Agir → Observer → recommencer.

Faites tourner la boucle,étape par étape.

Plus d'étapes, plus d'occasions de dérailler.

Quiz rapide.

À retenir

Function Calling : comment un LLM choisit un outil

Un LLM ne fait toujours
qu'une seule chose : prédire le prochain token.

Faites tourner la boucle,
étape par étape.