↓ Aller au contenu

Boucles agentiques

1. Introduction
#

Une boucle agentique (Agent Loop) est un mécanisme itératif permettant à un agent IA d’enchaîner des décisions et des actions jusqu’à l’atteinte d’un objectif ou d’une condition d’arrêt.

Contrairement à un workflow strictement prédéfini, l’agent peut adapter les étapes suivantes en fonction des résultats obtenus.

Une boucle agentique repose généralement sur cinq opérations :

  1. Observation : analyser le contexte et l’état actuel.
  2. Décision : déterminer la prochaine action.
  3. Action : exécuter un outil ou produire une réponse.
  4. Évaluation : examiner le résultat.
  5. Continuation ou arrêt : poursuivre ou terminer l’exécution.

La boucle est orchestrée par le harness, qui gère les appels au modèle, l’exécution des outils et les conditions d’arrêt.


2. Fonctionnement d’une boucle agentique
#

Chaque itération peut comprendre un ou plusieurs appels au modèle et aux outils.

ÉtapeResponsabilitéExemple
InputRecevoir l’objectifCorriger une fonction Python
ReasoningAnalyser le problèmeIdentifier une cause probable
PlanningPréparer une ou plusieurs actionsExaminer les tests
ActionExécuter une opérationModifier un fichier
ObservationRécupérer les résultatsLire la sortie de pytest
FeedbackAjuster la démarcheCorriger une nouvelle erreur
StopTerminer ou interrompreTests réussis ou limite atteinte

Ces opérations ne correspondent pas nécessairement à des appels LLM distincts. Certaines peuvent être regroupées ou gérées directement par le harness.

La boucle permet d’adapter l’exécution à des situations qui n’étaient pas entièrement prévisibles.

Raisonnement et planification
#

Deux notions doivent être distinguées :

  • Reasoning : traitement du problème et choix d’une action.
  • Planning : organisation des actions à réaliser, éventuellement sur plusieurs étapes.

Un agent peut agir sans produire de plan explicite.

De même, les étapes de raisonnement internes au modèle ne sont pas nécessairement accessibles ni directement vérifiables.


3. Les principaux patterns agentiques
#

Plusieurs patterns permettent d’organiser les décisions, les actions et les vérifications.

PatternPrincipeCas d’utilisation
ReActAlterner décisions, actions et observationsExploration de code, recherche d’informations
Plan-and-ExecuteConstruire un plan, puis exécuter ses étapesDéveloppement d’une fonctionnalité
ReflectionRéexaminer une production pour l’améliorerCorrection ou révision
Evaluator-OptimizerProduire, évaluer, puis améliorer selon un retourGénération de code ou de rapports
Retry / RecoveryRéessayer ou adapter une action après un échecErreur d’API, test échoué

Ces patterns peuvent être combinés. Ils ne constituent pas nécessairement des architectures exclusives.

3.1. ReAct (Reasoning and Acting)
#

Le pattern ReAct associe la prise de décision à l’utilisation d’outils et à l’observation de leurs résultats.

L’agent choisit progressivement les prochaines actions, sans nécessiter un plan complet dès le départ.

Exemple :

  • Examiner un fichier Python.
  • Identifier une dépendance potentiellement problématique.
  • Consulter les fichiers de configuration.
  • Modifier le code.
  • Exécuter les tests et examiner leurs résultats.

Avantage : adaptation aux informations découvertes.

Limite : risque d’itérations nombreuses ou d’actions peu pertinentes.

3.2. Plan-and-Execute
#

Le pattern Plan-and-Execute sépare la planification de l’exécution.

L’agent commence par établir les étapes nécessaires, puis les réalise successivement.

Exemple : création d’un pipeline Data Engineering

  1. Examiner les sources de données.
  2. Définir les transformations.
  3. Implémenter le pipeline.
  4. Ajouter les contrôles qualité.
  5. Exécuter les tests.

Le plan peut être révisé lorsque de nouvelles informations apparaissent.

Avantage : meilleure structuration des tâches complexes.

Limite : un plan initial incorrect peut orienter toute l’exécution.

3.3. Reflection et Evaluator-Optimizer
#

La Reflection consiste à réexaminer un résultat afin d’identifier des erreurs ou des améliorations.

Le pattern Evaluator-Optimizer formalise cette démarche en distinguant :

  • Generator : produit une première solution.
  • Evaluator : examine la solution selon des critères.
  • Optimizer : améliore la solution à partir du retour.

Ces rôles peuvent être assurés par un seul modèle, plusieurs appels LLM ou des composants distincts.

Exemple : générer une requête SQL, vérifier son résultat, puis corriger les anomalies détectées.

La qualité de l’évaluation reste déterminante. Une auto-évaluation par LLM ne remplace pas des tests objectifs.


4. Gestion des erreurs et récupération
#

Les agents doivent pouvoir réagir aux échecs rencontrés pendant l’exécution.

StratégieDescription
RetryRéexécuter une opération après un échec temporaire
BackoffAugmenter le délai entre plusieurs tentatives
FallbackUtiliser une méthode ou un outil alternatif
ReplanningRéviser le plan initial
RollbackAnnuler des modifications lorsque cela est possible
EscalationDemander une intervention humaine

Exemple : lorsqu’un appel API échoue, l’agent peut vérifier le type d’erreur, réessayer si elle est temporaire ou signaler un problème d’authentification.

Il faut éviter les tentatives répétées sans modification de stratégie.

Une erreur permanente (permissions insuffisantes, ressource inexistante) ne se résout généralement pas avec davantage d’itérations.


5. Conditions d’arrêt
#

Une boucle agentique doit disposer de conditions d’arrêt explicites.

ConditionDescription
Objectif atteintLes critères de réussite sont satisfaits
Final OutputLe modèle produit une réponse finale
Max IterationsNombre maximal d’itérations atteint
TimeoutDurée maximale dépassée
BudgetLimite de consommation atteinte
Repeated FailuresÉchecs successifs ou absence de progression
Human ApprovalExécution suspendue en attente d’autorisation

Il faut distinguer l’arrêt de la boucle de la réussite de la tâche.

Un agent peut terminer normalement sans avoir atteint son objectif, ou être interrompu après avoir effectué des modifications partielles.

Une réponse finale du modèle ne constitue donc pas, à elle seule, une preuve de réussite.


6. Boucles synchrones, asynchrones et supervision
#

L’exécution d’un agent peut être organisée de différentes manières.

ModeFonctionnementExemple
SynchroneL’application attend le résultat de l’exécutionAnalyse ponctuelle
AsynchroneL’exécution est suivie sans bloquer le processus appelantTraitement long
SuperviséCertaines actions nécessitent une validationModification sensible
Autonome encadréL’agent poursuit dans un périmètre autoriséTests et refactoring

L’asynchronisme et le niveau d’autonomie sont deux dimensions indépendantes.

Une exécution asynchrone n’implique pas nécessairement une exécution sans supervision humaine.

Human-in-the-Loop (HITL)
#

Une boucle peut être suspendue pour obtenir une validation humaine.

Celle-ci peut être nécessaire avant :

  • une suppression de données ;
  • une modification importante ;
  • une opération irréversible ;
  • un déploiement en production.

La reprise dépend du support de gestion d’état et de persistance fourni par l’environnement d’exécution.


7. Évaluation et optimisation des boucles
#

Une boucle agentique ne doit pas être évaluée uniquement sur sa capacité à terminer une tâche.

IndicateurObjectif
Success RateMesurer la proportion de tâches correctement réalisées
IterationsSuivre le nombre d’itérations
Tool CallsMesurer les appels d’outils
Token UsageSurveiller la consommation de tokens
LatencyMesurer la durée d’exécution
CostÉvaluer le coût global
Failure RateIdentifier les échecs et blocages

Bonnes pratiques
#

  • Définir des critères de réussite vérifiables.
  • Limiter les itérations et les coûts.
  • Éviter les appels d’outils inutiles.
  • Journaliser les actions et leurs résultats.
  • Prévoir des stratégies de récupération.
  • Privilégier des vérifications déterministes lorsque cela est possible.

Une boucle plus longue n’est pas nécessairement plus efficace. L’objectif est d’obtenir un résultat fiable avec une complexité et un coût maîtrisés.


8. Synthèse
#

Les boucles agentiques permettent à un agent d’adapter progressivement ses actions selon les résultats obtenus.

Les notions essentielles sont :

  • Agent Loop : succession itérative de décisions, actions et observations.
  • ReAct : décisions progressives guidées par les observations.
  • Plan-and-Execute : planification préalable puis exécution.
  • Reflection : réexamen critique d’une production.
  • Evaluator-Optimizer : amélioration itérative à partir d’une évaluation.
  • Recovery : adaptation après un échec.
  • Stopping Conditions : règles contrôlant la fin ou l’interruption d’une exécution.

La qualité d’une boucle agentique dépend autant de ses mécanismes de vérification et d’arrêt que des décisions prises par le modèle.


Références
#

Thibault CLEMENT - Intechnia
Auteur
Thibault CLEMENT - Intechnia
Data Scientist / ML Engineer