Accueil / Articles

Lorsqu’un agent IA échoue, qui en est responsable ? Analyse de la chaîne d’échecs

Pourquoi l’expression « le modèle a halluciné » est insuffisante : une analyse des étapes d’échec de l’agent, de l’intention et de la récupération d’informations aux outils, aux tentatives de réessai et aux traces, ainsi que des éléments à observer.

Éditeur : REACTAPP.TOP8 min de lecture1753 mots

Sources: When an AI Agent Fails, Who Do You Blame?

Image montrant une demande adressée à un agent IA pour réserver un vol pour São Paulo le lendemain matin, vers 9 heures. Quelques secondes plus tard, il répond que le vol a été réservé. Or ce n’est pas le cas : pas de billet, pas d’e-mail de confirmation, pas de frais facturés.

On pourrait être tenté de penser que l’IA a halluciné. C’est possible. Mais il se peut aussi que le modèle se soit comporté exactement comme prévu. L’API de réservation aurait pu retourner une erreur que l’agent a mal interprétée. L’agent a peut-être cherché des vols sans jamais utiliser l’outil de réservation. L’API a peut-être expiré après avoir finalisé la transaction. L’outil a peut-être fourni une estimation et non une réservation confirmée. Ou bien l’expression « demain matin » a pu être interprétée dans le mauvais fuseau horaire.

Lorsque les systèmes d’IA commencent à effectuer des tâches au lieu de se contenter de répondre à des questions, il devient beaucoup plus difficile d’expliquer les échecs. Cela crée un nouveau problème d’ingénierie : lorsque l’agent échoue, qui ou quoi en porte la responsabilité ?

Le logiciel ancien était plus facile à déboguer

Le logiciel conventionnel peut être complexe, mais son parcours d’exécution est généralement familier :

User
  ↓
Frontend
  ↓
Backend
  ↓
Database

Lorsqu’il y a une panne, les endroits à vérifier sont bien connus : savoir si la demande est parvenue au backend, si la base de données est tombée en panne, si une API intermédiaire est bloquée, ou si une exception a été levée. Les journaux, les métriques et les traces aident à reconstituer ce qui s’est passé.

Un agent, lui, est complètement différent :

User Request
      ↓
Interpret Intent
      ↓
Retrieve Context
      ↓
Create a Plan
      ↓
Select a Tool
      ↓
Call the Tool
      ↓
Interpret the Result
      ↓
Reason Again
      ↓
Final Answer

Ici, une réponse HTTP réussie ne dit pas grand-chose. Le système peut renvoyer

200 OK

et fait quand même quelque chose de complètement faux. C’est là la différence fondamentale entre la surveillance classique et l’observabilité par l’IA : un système peut être en bon état du point de vue opérationnel tout en présentant un comportement erroné.

« Le modèle a halluciné » est le nouveau « L’ordinateur est cassé »

Presque tous les résultats négatifs générés par l’IA sont qualifiés de hallucinations, et cette étiquette s’érode rapidement. Supposons qu’un assistant affirme que votre entreprise accorde 30 jours de congé payé, alors que la politique réelle prévoit 22 jours. Une hallucination ? Peut-être. Mais imaginez que la politique correcte se trouve dans le stockage de documents et que la récupération en ait tiré une version obsolète. Le modèle a pu répondre parfaitement compte tenu du contexte qui lui a été fourni. Le modèle n’a pas échoué ; c’est le processus de traitement du contexte qui a échoué, et remplacer le modèle ne réparera pas le système.

La pile d’échecs des agents

Un modèle mental utile considère un système agentiel comme une série d’étapes où des erreurs peuvent survenir :

┌───────────────────────────┐
│       User Intent         │
├───────────────────────────┤
│ Prompt / Instructions     │
├───────────────────────────┤
│ Context / Retrieval       │
├───────────────────────────┤
│ Memory                    │
├───────────────────────────┤
│ Planning / Reasoning      │
├───────────────────────────┤
│ Tool Selection            │
├───────────────────────────┤
│ Tool Parameters           │
├───────────────────────────┤
│ Tool Execution            │
├───────────────────────────┤
│ External Systems          │
├───────────────────────────┤
│ Orchestration             │
├───────────────────────────┤
│ Infrastructure            │
└───────────────────────────┘

On peut l’appeler l’empilement des échecs de l’agent. L’essentiel est que la réponse finale n’est que la partie visible d’un chemin d’exécution bien plus long.

1. L’agent a mal interprété les informations

Demandez à un assistant d’annuler la réunion de vendredi avec John. Il trouve un événement récurrent intitulé « Weekly Sync with John » et supprime toute la série d’événements. L’API de calendrier a fonctionné, l’authentification a fonctionné, la suppression a réussi. L’échec est survenu avant même qu’aucun outil ne soit appelé :

User Intent
     ↓
Wrong Interpretation
     ↓
Correct Tool Call
     ↓
Wrong Outcome

C’est une défaillance d’intention, et c’est dangereux car tout ce qui suit l’erreur initiale peut fonctionner parfaitement.

2. Les informations étaient là, mais l’agent ne les a jamais vues

Prenons l’exemple d’un assistant juridique qui lit un contrat stipulant que chacune des parties peut y mettre fin après 90 jours. Le système de recherche envoie au modèle une clause voisine concernant une période de préavis de 30 jours, et l’IA en déduit que le contrat peut prendre fin après 30 jours. Une fois de plus, le modèle peut tirer des conclusions logiques à partir d’informations erronées :

Documents
    ↓
Retrieval
    ↓
Wrong Chunk
    ↓
Model
    ↓
Wrong Answer

Le problème réside dans la récupération des informations et non nécessairement dans leur génération. Traiter un bug lié au RAG ressemble souvent à l’ajustement d’un moteur de recherche plutôt qu’à la correction d’un chatbot.

3. La mémoire peut rendre un système intelligent dépassé de manière significative

Les agents intègrent de plus en plus de mémoire, ce qui est utile tant qu’elle n’est pas obsolète. Supposons que l’agent se souvienne

Customer Plan = Basic

Mais le client a effectué une mise à niveau la semaine dernière et l’état réel est

Customer Plan = Enterprise

L’agent refuse une fonction à laquelle l’utilisateur a droit. Rien ne s’est détraqué, et le stockage mémoire a fait exactement ce pour quoi il a été conçu. Il s’est simplement accroché à quelque chose qui n’était plus vrai. Parfois, oublier est tout aussi important que se souvenir.

Les outils augmentent les enjeux

Les LLM génèrent du texte. Les agents génèrent des actions, ce qui modifie le risque. Donnez à un agent deux outils :

search_customer()
update_customer()

L’utilisateur demande quel est l’adresse enregistrée pour Sarah. L’outil évident est

search_customer()

pourtant le modèle choisit

update_customer()

C’est une erreur de sélection d’outil. Ou bien il choisit l’outil approprié et tout se passe bien.

{
  "currency": "USD"
}

où la valeur correcte était

{
  "currency": "BRL"
}

C’est une défaillance liée aux paramètres de l’outil. L’API peut fonctionner sans problème, mais le résultat reste incorrect.

Parfois, l’outil tombe en panne

Les systèmes externes sont complexes. Les API atteignent leur limite de temps, les bases de données se déconnectent, des limites de fréquence s’activent, les permissions expirent. Pensez à cette chaîne d’événements :

Agent
  ↓
Book Flight API
  ↓
TIMEOUT

Comment l’agent doit-il réagir : essayer à nouveau, demander à l’utilisateur, ou vérifier d’abord s’une réservation existe ? Supposons maintenant que la réservation a bien été effectuée mais que la confirmation a été perdue en rentrant, alors l’agent tente une deuxième fois :

First booking  → SUCCESS
Response       → LOST
Retry          → SUCCESS

Le client possède maintenant deux billets. Il ne s’agit plus uniquement d’un problème lié à l’IA. C’est un problème classique des systèmes distribués, et les tentatives répétées, l’idempotence, la gestion de l’état et les transactions font désormais partie de l’ingénierie de l’IA.

Les configurations multi-agents rendent la responsabilité plus floue

Imaginons maintenant trois agents en séquence :

Research Agent
      ↓
Analysis Agent
      ↓
Writing Agent

L’agent de recherche trouve les faits appropriés. L’agent d’analyse les interprète correctement. L’agent d’écriture omet une qualification importante, ce qui conduit à une réponse erronée. Quel agent a échoué ? Les systèmes d’agents ressemblent de plus en plus à des logiciels distribués dont les composants prennent des décisions probabilistes, ce qui rend l’observabilité essentielle.

Les traces sont plus importantes que les journaux

Supposons qu’un agent produise une réponse catastrophique tandis que le tableau de bord de l’infrastructure affiche :

HTTP Status: 200
Latency: 3.8s
CPU: Normal
Memory: Normal
Errors: 0

Tout semble fonctionner correctement, pourtant la réponse est fausse. La surveillance classique indique simplement que le système a fonctionné. Les ingénieurs doivent savoir pourquoi il a pris cette décision. Cela exige quelque chose qui ressemble davantage à un suivi d’agent :

TRACE #84721
User Request
      ↓
Intent: "Book Flight"
      ↓
Retrieved user preferences
      ↓
Planner created 3 steps
      ↓
search_flights()
      ↓
Selected Flight #2
      ↓
book_flight()
      ↓
API response: timeout
      ↓
Agent assumed success
      ↓
Final response:
"Your flight has been booked."

Désormais, cette panne peut être traitée. L’agent n’a pas simplement inventé un vol : le système a considéré un état d’outil inconnu comme une transaction terminée, et c’est quelque chose que les ingénieurs peuvent corriger.

Ce qu’un trace doit capturer

Un trace utile d’agent pourrait contenir :

trace_id
user_requestmodel_versionprompt_versionretrieved_contextmemory_usedtool_callstool_parameterstool_resultsretrieslatencytoken_usagecostfinal_answerevaluation_result

Il n’est pas nécessaire que chaque application stocke tous les champs, car la confidentialité, la sécurité et les coûts restent des facteurs importants. Le principe est cependant simple : si un agent doit effectuer dix étapes pour obtenir une réponse, ne consigner que la première entrée et la dernière sortie revient à diagnostiquer une architecture de microservices en ne notant que la première requête et la réponse finale. Cela ne sert pas à grand-chose.

Le suivi n’est pas l’observabilité

Cette distinction est particulièrement utile pour les systèmes d’IA. Le suivi permet de déterminer s’il y a un problème. Le traçage permet de savoir quel chemin a suivi la tâche. L’observabilité permet de comprendre pourquoi le système s’est comporté de cette manière. L’évaluation permet de déterminer si ce comportement était effectivement bon.

Monitoring
"Is the system healthy?"
        ↓
Tracing
"What path did it follow?"
        ↓
Observability
"Why did it behave this way?"
        ↓
Evaluation
"Was the result correct?"

Le génie de l’IA a besoin des quatre éléments.

Les métriques doivent également évoluer

Les services conventionnels sont évalués à l’aide de chiffres tels que

Availability
Latency
Throughput
Error Rate

et ceux-ci restent importants. Les agents ajoutent de nouvelles questions :

Task Success Rate
Tool Success RateRetrieval Success RateTrajectory Success RateHuman Escalation RateAverage Steps per TaskTokens per TaskCost per TaskCost per Successful Task

Le dernier exemple est particulièrement révélateur. Un agent qui coûte 0,01 dollar par demande mais réussit seulement la moitié du temps peut s’avérer moins avantageux qu’un autre qui coûte 0,03 dollar et réussit 98 % du temps. Le système d’IA le moins cher n’est pas nécessairement celui basé sur le modèle le moins cher ; c’est celui qui produit le résultat réussi au coût le plus bas.

Alors, qui est à blâmer ?

Revenons au vol. L’utilisateur a demandé une réservation pour São Paulo le lendemain matin, l’agent a répondu « Fait », or aucun billet n’existe. Le modèle ? Peut-être. La requête ? Probablement. Ou bien le système de récupération des données, l’outil de réservation, l’API de la compagnie aérienne, l’orchestrateur, l’infrastructure ?

La réponse déplaisante est qu’on ne peut le savoir qu’une fois que l’exécution a pu être reconstituée. Cela marque un tournant majeur dans l’ingénierie de l’IA. Lorsque les modèles se transforment en agents, et que ces agents deviennent des systèmes complets, la fiabilité cesse d’être une propriété exclusive du modèle pour devenir une propriété de l’ensemble du parcours d’exécution :

Model Quality
     +
Context Quality
     +
Tool Reliability
     +
Orchestration
     +
Infrastructure
     +
Evaluation
     +
Observability
     ↓
Reliable AI System

Des modèles plus performants seront certainement utiles, mais la seule capacité ne suffit pas à rendre les systèmes d’IA fiables. Les principes fondamentaux que les ingénieurs logiciels ont passé des décennies à apprendre à respecter restent valables : journaux d’activité, traçabilité, délais de timeout, tentatives de réessai, permissions, état du système, tests, métriques et analyse des pannes. Lorsqu’un agent échoue en production, l’expression « le modèle a halluciné » finira par sembler aussi utile que « l’ordinateur a fait quelque chose d’étrange ». L’ingénierie commence au moment où cette explication cesse d’être suffisante.