Quand un agent fonctionne bien, cela ressemble à de la magie.
Tu lui donnes une tâche, tu n’expliques rien, tu ne contrôles pas chaque étape, et le système trouve des données, choisit des outils, puis revient avec un résultat.
Et à un moment, on commence à croire qu’il comprend ce qu’il fait.
Et puis soudain :
- Il utilise le mauvais outil
- Il oublie la moitié de la tâche
- Il fait une requête API inutile
- Ou il renvoie en toute confiance un non-sens complet
Et le pire : il le fait de manière très convaincante.
Sans erreurs de texte.
Sans hésitation.
Comme si tout était correct.
À ce moment-là, une question logique apparaît :
Comment un système qui venait d’agir intelligemment a-t-il pu se tromper autant ?
Parce qu’à l’intérieur, il n’y a pas de raisonnement
Pour comprendre pourquoi un agent se trompe parfois, il faut regarder comment il prend réellement ses décisions.
Parce qu’à l’intérieur de lui, il n’y a pas de "raisonnement".
Un agent IA ne pense pas. Il ne vérifie pas les faits. Il ne comprend pas ce qui est juste ou faux.
Il fonctionne via un modèle de langage.
Et un modèle de langage ne connaît pas les réponses.
Il ne cherche pas la vérité. Il n’ouvre pas une base de connaissances. Il ne vérifie pas la réalité.
Il choisit l’action ou la réponse suivante qui paraît la plus probable dans ce contexte.
Chaque fois que l’agent :
- Décide l’étape suivante
- Choisit un outil
- Écrit une requête
- Ou évalue un résultat
— ce n’est qu’une tentative de deviner ce qui semble le plus correct dans ce contexte.
Et parfois cette supposition est fausse.
| Humain | LLM | |
|---|---|---|
| Vérifie les faits | ✅ | ❌ |
| Connaît la réponse | Parfois | ❌ |
| Prédit la réponse | ❌ | ✅ |
Comment l’agent prend réellement ses décisions
L’agent ne sait pas quelle action est correcte.
Mais il est entraîné sur une énorme quantité d’exemples de ce à quoi ressemble une action correcte dans des situations similaires.
Pendant l’entraînement, le modèle a vu :
- À quoi ressemblent les requêtes API
- Comment on analyse des données
- Comment on construit des rapports
- Comment on utilise des outils
Et maintenant, quand l’agent travaille, il regarde :
- L’objectif
- Les étapes précédentes
- Les résultats obtenus
Et il se pose la question :
"Quelle action ressemble le plus à celle qui aidait dans une situation similaire auparavant ?"
Par exemple, quand tout se passe bien :
L’agent reçoit une tâche : "Collecte les données du client."
Le contexte contient un outil : get_user_data(user_id)
Le modèle "sait" que dans des tâches similaires :
- On récupère d’abord les données
- Puis on les analyse
Donc il choisit : appeler get_user_data
Pas parce qu’il est certain.
Mais parce que cela ressemble à l’étape logique suivante.
Mais voilà quand ça se passe mal :
L’agent reçoit une tâche : "Écris un court aperçu de l’entreprise pour un nouveau client."
Dans le contexte, il y a d’anciennes notes de réunion d’un autre client, avec un format similaire.
Le modèle voit un schéma similaire et pense :
"Dans une situation similaire, on utilise généralement les données déjà disponibles."
Et il génère donc un aperçu, mais sur une autre entreprise.
Avec assurance. Sans avertissement. Avec un texte bien formaté.
Simplement pas sur le bon client.
Après chaque étape, il refait une prédiction :
"Qu’est-ce qu’on fait en général après ça ?"
Et ainsi de suite, étape par étape.
C’est exactement pour cela qu’un agent fait souvent des actions correctes.
Mais parfois, non.
Parce qu’il ne vérifie pas si c’est vrai.
Il choisit seulement ce qui semble le plus pertinent dans ce contexte.
En code, cela ressemble à ça
Ci-dessous, le même principe dans un format simple :
le modèle ne "connaît pas la vérité", il choisit l’étape qui semble la plus probable dans le contexte actuel.
D’abord, nous avons des actions (outils) qu’on peut appeler :
def fetch_company_profile(company_id: str):
return {"company_id": company_id, "summary": "Official profile"}
def summarize_notes(notes: str):
return {"summary": f"Summary from notes: {notes}"}
TOOLS = {
"fetch_company_profile": fetch_company_profile,
"summarize_notes": summarize_notes,
}
Maintenant, nous avons le contexte de la tâche :
state = {
"task_company_id": "acme",
"old_notes": "Meeting notes about beta-corp", # anciennes notes sur une autre entreprise
}
Le modèle fait une supposition sur l’étape suivante :
def choose_action(state: dict):
# S'il y a déjà des notes dans le contexte, le modèle peut décider
# que cela "suffit" pour un aperçu rapide.
if state.get("old_notes"):
return {
"tool": "summarize_notes",
"parameters": {"notes": state["old_notes"]},
}
return {
"tool": "fetch_company_profile",
"parameters": {"company_id": state["task_company_id"]},
}
Le système exécute ce que le modèle a proposé :
model_output = choose_action(state)
tool_name = model_output["tool"]
params = model_output["parameters"]
result = TOOLS[tool_name](**params)
Dans ce cas, le résultat sera "convaincant", mais sur la mauvaise entreprise :
# {'summary': 'Summary from notes: Meeting notes about beta-corp'}
Pour réduire le risque, on ajoute une vérification simple de la source avant la réponse finale :
def validate_summary_source(state: dict, result: dict):
if "beta-corp" in result.get("summary", "") and state["task_company_id"] == "acme":
return {"error": "Incohérence de contexte : données sur la mauvaise entreprise"}
return {"ok": True}
Cela ne supprime pas complètement les limites du LLM, mais cela réduit ce type d’erreurs en production.
Exemple complet d’implémentation avec LLM connectée
Analogie de la vie réelle
Imagine un cuisinier débutant qui a regardé des milliers de vidéos de recettes.
Il a vu :
- Comment faire griller de la viande
- Comment faire une soupe
- Comment préparer des sauces
- Comment dresser des plats
Mais il ne se souvient d’aucune recette mot à mot.
Et il ne sait pas avec certitude comment préparer correctement chaque plat.
Maintenant, tu lui demandes : "Prépare quelque chose de proche d’une carbonara."
Il n’ouvre pas de livre. Il ne vérifie pas d’instructions.
Il pense :
"Qu’est-ce qu’on fait généralement dans un plat similaire ?"
Et :
- Ajoute de la crème
- Fait revenir du bacon
- Mélange avec des pâtes
Parfois c’est très bon.
Parfois c’est étrange.
Parce qu’il ne sait pas ce qui est correct.
Il fait simplement ce qui ressemble le plus à une recette correcte vue auparavant.
Un agent fonctionne de la même manière.
Il ne sait pas quelle action est correcte. Et il ne mémorise pas de solutions prêtes à l’emploi.
Il choisit celle qui ressemble le plus à la bonne dans une situation similaire.
En bref
Un modèle de langage n’est pas un raisonnement :
- Il ne connaît pas les bonnes réponses
- Il ne vérifie pas les faits
- Il ne fait que générer la continuation la plus probable
C’est précisément pour cela qu’un agent peut paraître très intelligent et en même temps se tromper avec assurance, sans aucun avertissement.
Ce n’est pas un bug d’un système spécifique. C’est la nature fondamentale du fonctionnement des modèles de langage.
Que faire ? Comprendre cette limite est déjà la première étape. Ensuite, il existe des moyens concrets de rendre l’agent plus fiable : lui donner un contexte clair, limiter les outils, ajouter une validation des résultats. Et l’un des plus importants est de lui donner de la mémoire.
FAQ
Q: Est-ce qu’un agent sait que sa réponse est correcte ?
A: Non. Il choisit l’option qui paraît la plus probable dans ce contexte.
Q: Le modèle peut-il se vérifier lui-même ?
A: Il peut essayer d’évaluer sa réponse, mais ce sera encore une supposition.
Q: Pourquoi l’agent semble-t-il sûr de lui même quand il se trompe ?
A: Parce que le modèle est entraîné à générer un texte plausible, pas à douter.
Et ensuite
Maintenant, tu sais pourquoi un agent peut se tromper et que ce n’est pas de la négligence, mais la nature même de la technologie.
Il y a plusieurs façons de rendre un agent plus fiable : des instructions claires, un ensemble d’outils limité, la validation des résultats. Mais l’une des plus efficaces et des plus intéressantes est la mémoire.
Si un agent peut retenir :
- Ce qui a déjà été fait
- Quels outils ont fonctionné
- Quelles données il a obtenues avant
Il commence à moins dépendre des suppositions et davantage de l’expérience concrète dans cette tâche.
C’est exactement le sujet du prochain article.