Tout agent IA est un modèle qui appelle des outils dans un certain ordre. La seule vraie question est : qui décide de cet ordre ? Dans un agent en boucle, le modèle décide à l’exécution. Dans un agent en graphe, vous définissez l’ordre à l’avance et le modèle remplit les étapes. La plupart des débats sur les frameworks d’agents portent en réalité sur ce choix précis.
Un agent en boucle est la solution la plus simple qui fonctionne : envoyer au modèle la tâche et une liste d’outils, exécuter l’outil demandé, ajouter le résultat, puis recommencer jusqu’à obtenir une réponse sans appel d’outil. C’est le modèle ReAct. Les API d’utilisation d’outils d’OpenAI et d’Anthropic, le Vercel AI SDK et createAgent de LangChain le proposent directement. Il est étonnamment capable : la plupart des assistants de programmation et agents de recherche reposent exactement sur cette boucle.
Son atout est la souplesse : nul besoin de connaître le parcours à l’avance, ce qui convient naturellement aux tâches ouvertes — recherche, débogage, « découvre pourquoi cette commande a échoué ». Sa faiblesse est la même. Le nombre d’étapes est inconnu, donc le coût et la latence le sont aussi. Le modèle peut tourner en rond, sauter un contrôle ou appeler un outil que vous vouliez éviter. Des garde-fous le maintiennent dans les limites : nombre maximal d’étapes (stopWhen dans le Vercel AI SDK), budget de jetons, liste d’outils autorisés et validation de la réponse finale.
Un agent en graphe représente le processus par des nœuds et des arêtes explicites : classer, récupérer, rédiger, valider, interroger une personne, écrire. Chaque nœud peut être un appel au modèle, un outil ou du code classique ; les arêtes peuvent bifurquer ou revenir volontairement en arrière — « validation échouée, retourne à la rédaction ». L’état est un objet explicite enregistré après chaque nœud. LangGraph en est l’exemple le plus connu : en Python et en TypeScript, ses points de contrôle permettent de suspendre une exécution pour une approbation humaine, puis de la reprendre des heures plus tard exactement à l’endroit où elle s’était arrêtée.
Son avantage est le contrôle. Vous savez quelles étapes peuvent se produire, dans quel ordre et où une personne doit approuver. Chaque exécution se trace nœud par nœud, le graphe borne le coût et un échec à la cinquième étape ne relance pas les quatre premières. En contrepartie, il faut concevoir le graphe à l’avance et accepter moins de liberté : si une tâche n’y entre pas, l’agent ne peut pas improviser une sortie.
Délai avant le premier prototype
Tâches ouvertes
Coût et latence prévisibles
Débogage et traçage
Approbations humaines
Processus longs et reprenables
Écritures sûres (argent, données personnelles)
Afficher en tableau
| Critère | Agent en boucle | Agent en graphe |
|---|---|---|
| Délai avant le premier prototype | 5 / 5 | 2 / 5 |
| Tâches ouvertes | 5 / 5 | 2 / 5 |
| Coût et latence prévisibles | 2 / 5 | 4 / 5 |
| Débogage et traçage | 2 / 5 | 5 / 5 |
| Approbations humaines | 2 / 5 | 5 / 5 |
| Processus longs et reprenables | 1 / 5 | 5 / 5 |
| Écritures sûres (argent, données personnelles) | 2 / 5 | 5 / 5 |
La comparaison directe pose moins la question « lequel est le meilleur ? » que « où se situe votre tâche ? » : entre ouvert et répétable, entre erreurs peu coûteuses et erreurs lourdes de conséquences. Détail intéressant, la frontière est moins nette que ne le prétend le marketing. Le createAgent de LangChain est une boucle, mais depuis la version 1.0 il s’exécute sur le runtime LangGraph : une boucle est simplement le plus petit graphe possible.
Taille de la bulle : nombre habituel d’appels du modèle par tâche
Afficher sous forme de liste
- Un seul appel au modèle — Un prompt, une réponse : le plus prévisible, le moins autonome. (1 appel au modèle)
- Agent en graphe — Étapes et embranchements définis ; le modèle agit dans chaque nœud. (un nombre fixe d’appels)
- Graphe avec une boucle interne — Un processus fixe avec une étape ouverte, comme la recherche. (étapes fixes + boucle limitée)
- Agent en boucle — Le modèle choisit chaque étape jusqu’à la fin. (autant d’appels que nécessaire)
Ma règle : commencer par une boucle pour l’exploration et les outils internes, quand une personne lira de toute façon le résultat. Passer au graphe si le processus se répète, touche à l’argent ou aux données client, nécessite une validation ou dépasse la durée d’une requête. Les meilleurs systèmes de production combinent souvent les deux : un graphe pour le processus métier et une petite boucle dans l’un de ses nœuds — par exemple une étape de recherche qui peut lancer plusieurs recherches avant de transmettre un résultat propre au nœud déterministe suivant.
Quel que soit le choix, les règles ne changent pas : entrées d’outils typées, budget strict, journal de chaque étape et aucune écriture dans le système de référence sans validation. En TypeScript ou en Python, cela représente quelques dizaines de lignes autour de l’appel au modèle — et c’est ce qui sépare une démo d’un produit. Si vous souhaitez confier un processus à un agent, envoyez-moi les étapes telles que votre équipe les exécute aujourd’hui. Je vous dirai s’il faut une boucle, un graphe ou un graphe avec une boucle intégrée.
Donnez à votre prochain produit quelqu’un qui reste.
Prêt à commencer ? Écrivez-moi — je peux démarrer immédiatement et rester dans la durée. Des collaborations à long terme, pas une passation après deux semaines. Discutons de votre projet, de vos exigences et de la meilleure façon d’avancer.