# Que sont les boucles et les graphes en IA, et pourquoi sont-ils importants? Date: 2026-11-03 · Author: Robert Scales · https://guidetoartificialintelligence.com/fr/apprendre/boucles-et-graphes-ia-expliques/ **Answer:** Une boucle d’IA rend un morceau de travail correct en le produisant, en le vérifiant avec un test capable de le refuser, en corrigeant ce qui a échoué et en recommençant; un graphe décide quels morceaux de travail existent, lesquels roulent en parallèle, comment ils se relient et où se placent les vérifications et les approbations humaines. Ils sont importants parce que l’impression d’un modèle que son travail est bon n’est pas une preuve, et que les boucles et les graphes servent à placer de vraies preuves et le jugement d’une personne là où ils comptent. Demandez à un modèle d’écrire quelque chose et vous obtenez une tentative. Demandez-lui de vérifier sa propre tentative et il l’approuvera presque toujours : Anthropic a rapporté en mars 2026 que les agents qui notent leur propre travail ont tendance à en faire l’éloge, même quand une personne voit bien qu’il est médiocre. Une bonne part de l’ingénierie utile autour de l’IA consiste aujourd’hui à dépasser cette première tentative sans se fier à l’opinion que le modèle a de lui-même. Deux formes font l’essentiel du travail. Une **boucle** rend correct un morceau de travail. Un **graphe** organise plusieurs morceaux de travail et décide où vont les vérifications et les personnes. Cette page définit le vocabulaire, suit un exemple du début à la fin et renvoie aux articles de cette section qui approfondissent chaque partie. ## Les mots, définis une fois | Terme | Sens | Exemple | |---|---|---| | **Unité** | Un morceau de travail assez petit pour être vérifié seul | Une page produit, une correction de bogue, une question répondue | | **Exécutant** (*worker*) | Ce qui produit une ébauche d’une unité : un appel à un modèle, un agent, parfois du simple code | Un modèle qui réécrit une page à partir d’une consigne | | **Vérification** | Un test de l’ébauche qui peut la refuser sans que personne surveille, à partir de preuves que l’exécutant ne peut pas modifier | Les tests se terminent par une erreur; une affirmation n’a pas de ligne source correspondante; un fichier hors du plan a changé | | **Barrière** (*gate*) | Un point que le travail ne peut franchir avant qu’une vérification (ou une personne) dise oui | « Seules les pages dont chaque prix correspond à la grille de prix avancent » | | **Boucle** | Produire, vérifier, corriger, recommencer, avec une limite de tentatives | Trois essais par page, puis la page va à une personne | | **Graphe** | La carte de toutes les étapes et du chemin que suit le travail entre elles | Découper le travail, faire rouler les exécutants en parallèle, filtrer chaque résultat, fusionner | | **Nœud** | Une étape du graphe | Un découpeur, un exécutant, une étape en simple code, une barrière | | **Arête** | Un lien qui dit ce qui roule ensuite, parfois avec une condition | « Si la barrière échoue, retourner à l’exécutant » | Trois choses ne sont pas des vérifications, même si on s’en sert souvent comme si elles l’étaient : « ça a l’air bon », « le modèle se dit confiant » et « aucune erreur n’a été signalée ». Chacune laisse passer presque tout. L’article [Qu’est-ce qui rend réelle une vérification dans une boucle d’IA?](/fr/apprendre/verification-reelle-boucle-ia/) explique pourquoi, avec de vraies vérifications pour le code, l’écriture, la recherche et les données. ## Les boucles : rendre une unité correcte Une boucle répète quatre gestes : produire une ébauche, la vérifier, renvoyer ce qui a échoué avec les preuves, recommencer. Le guide d’Anthropic sur la création d’agents appelle une version de ce schéma le flux de travail **évaluateur-optimiseur** (*evaluator-optimizer*) : un appel au modèle produit une réponse et un autre l’évalue et donne une rétroaction, tour après tour. Le même guide insiste sur le fait que les agents ont besoin d’une « vérité terrain » (*ground truth*) tirée de leur environnement, comme le résultat de l’exécution réelle du code, et qu’un nombre maximal d’itérations garde une boucle sous contrôle. Les systèmes de recherche montrent à la fois la force et le point faible des boucles. Dans l’article sur Reflexion (2023), un agent transforme la rétroaction d’une tentative ratée en une courte réflexion écrite qu’il garde en mémoire pour l’essai suivant; en programmation, il écrit ses propres tests unitaires et s’en sert comme vérification. Les auteurs signalent aussi le piège : quand ces tests étaient faibles, de mauvaises solutions passaient, et l’agent s’arrêtait trop tôt pour les soumettre. Une boucle ne vaut que la vérification qu’elle contient. Deux règles en découlent. La vérification doit pouvoir refuser le travail sans que personne surveille, et la boucle doit s’arrêter : après un nombre fixe de tentatives, une unité non résolue va à une personne au lieu de refaire un tour. [Comment créer une boucle d’IA avec une vraie barrière?](/fr/apprendre/creer-boucle-ia-vraie-barriere/) construit exactement cela en environ 170 lignes de Python que vous pouvez exécuter sans clé d’API, avec des barrières pour les tests, les sources et la portée des fichiers. Le guide plus ancien [Comment créer une boucle générer, tester, réviser?](/fr/apprendre/boucle-generer-tester-reviser/) montre la même idée avec un modèle comme exécutant, et [Comment mettre en place une boucle d’auto-amélioration d’agent en toute sécurité?](/fr/apprendre/boucle-auto-amelioration-agent-securite/) l’applique à l’amélioration du prompt d’un agent. ## Les graphes : décider quelles unités existent et comment elles se relient Une boucle seule s’occupe d’une unité. Les vrais travaux en ont beaucoup : quarante pages, douze fichiers, trente sources. Un graphe décide comment découper le travail en unités, quelles unités peuvent rouler en même temps et où se placent les barrières. LangGraph, un cadriciel (*framework*) à code source ouvert répandu pour ce genre de travail, décrit un flux de travail comme un état partagé, plus des **nœuds** (des fonctions qui font un travail et renvoient des mises à jour) et des **arêtes** (des transitions fixes ou conditionnelles qui choisissent le nœud suivant). Les nœuds qui roulent en parallèle font partie de la même étape, et une fonction appelée `Send` lance le même exécutant une fois par élément, un schéma que sa documentation appelle *map-reduce*. La plupart des graphes utilisent une poignée de rôles de nœuds : - Un **découpeur** (*splitter*) divise le travail en unités. Le guide d’Anthropic appelle la version pilotée par un modèle **orchestrateur-exécutants** (*orchestrator-workers*) : un modèle central décompose la tâche, confie les morceaux à des exécutants et combine leurs résultats. - Des **exécutants** produisent les ébauches, souvent en parallèle. - Des **étapes en simple code** font ce que le code fait mieux qu’un modèle : récupérer un fichier, comparer deux nombres, compter des mots, fusionner des résultats. - Des **barrières** décident de ce qui avance. Un graphe a aussi deux sortes de chemins de retour. Une **arête de correction** est courte : elle renvoie une unité refusée à son exécutant avec la preuve de ce qui a échoué et l’étendue permise du changement (« le prix de la ligne 14 ne correspond pas à la grille; change seulement cette ligne »). Une **arête d’apprentissage** est plus longue : quand le même échec revient sans cesse, elle transforme la leçon en un changement de la consigne que reçoit chaque unité à venir (« les prix incluent les taxes; ne recopie jamais l’ancienne note sur les taxes »). L’arête de correction répare cette unité; l’arête d’apprentissage empêche les vingt suivantes de faire la même erreur. Une habitude compte plus que n’importe quel cadriciel : **renvoyer une seule unité refusée, pas le lot entier.** Si 37 pages sur 40 réussissent, tout relancer gaspille le travail déjà juste et donne au modèle 37 nouvelles occasions de briser quelque chose. [Comment concevoir un graphe d’agents d’IA?](/fr/apprendre/concevoir-graphe-agents-ia/) détaille les rôles des nœuds, les deux arêtes et cette règle avec un exemple complet. Les graphes ont un coût. Anthropic a rapporté en 2025 que son système de recherche multi-agents utilisait environ 15 fois plus de jetons qu’une conversation, et que les tâches où chaque agent a besoin du même contexte, comme la plupart du travail de programmation, s’y prêtaient mal. En octobre 2026, l’entreprise est allée plus loin en soutenant que beaucoup d’agents d’entreprise bâtis comme un routeur plus des sous-agents spécialisés feraient mieux sous la forme d’une seule boucle : [Faut-il construire une seule boucle d’agent ou une équipe de sous-agents?](/fr/apprendre/une-boucle-agent-ou-sous-agents/) expose cet argument, ses preuves et les autres points de vue. Pour l’idée de base de confier du travail à des agents auxiliaires, voyez [Que sont les sous-agents, et quand faut-il leur répartir le travail?](/fr/apprendre/sous-agents-repartir-travail/) et [Comment construire un flux de travail multi-agents?](/fr/apprendre/construire-flux-de-travail-multi-agents/). ## Où les personnes approuvent-elles? Une barrière n’a pas à être du code. Certaines décisions reviennent à une personne, et la question utile est de savoir où. Une règle solide consiste à placer l’approbation humaine selon le **rayon d’impact** (*blast radius*) : l’ampleur des dégâts qu’une mauvaise étape pourrait causer et la possibilité de la défaire. Les ébauches sur une branche, les fichiers dans un dossier de travail et les exécutions de tests peuvent boucler librement. Envoyer, payer, supprimer, déployer et fusionner dans ce que tout le monde utilise attendent une personne. Le degré de confiance qu’affiche le modèle n’entre pas en ligne de compte. En pratique, cela veut souvent dire une seule approbation à la fin, la fusion ou la publication finale, avec un court dossier devant la personne qui approuve : ce qui a changé, ce que les vérifications ont trouvé, ce qui a échoué puis été corrigé, et ce qui demande encore du jugement. Les cadriciels prennent cette pause en charge directement : dans LangGraph, un nœud appelle `interrupt()`, le graphe sauvegarde son état et attend, et la réponse de la personne relance l’exécution. [Où une personne devrait-elle approuver le travail dans une boucle d’IA?](/fr/apprendre/ou-approuver-boucle-ia/) traite ce sujet en détail, et [Comment garder une personne dans la boucle d’une automatisation?](/fr/apprendre/garder-humain-dans-boucle-automatisation/) montre le même principe dans une automatisation sans code. ## Un exemple concret : mettre à jour 40 pages produits Une boutique change ses prix et veut mettre à jour 40 pages produits à partir d’une nouvelle grille de prix. Voici le travail sous forme de graphe. ```text grille de prix + consigne │ [découpeur : une unité par page] (simple code) │ ┌────┼────┬─── … 40 unités, en parallèle [exécutant] [exécutant] [exécutant] (modèle) │ │ │ [barrière : chaque prix correspond à une ligne de la grille, les liens fonctionnent, seul le fichier de cette page a changé] (simple code) │ réussite │ échec → retour à son propre exécutant avec les preuves (3 essais max.) │ │ 3 échecs → liste pour une personne │ même échec sur 5 pages ou plus → arête d’apprentissage : ajouter une règle à la consigne │ [fusion des pages réussies en un seul changement] (simple code) │ [une personne approuve le changement avant la mise en ligne] ``` Supposons que 34 pages réussissent du premier coup. Quatre échouent parce que le modèle a arrondi 19,95 $ à 20 $; chacune retourne seule avec la ligne qui a échoué, et les quatre réussissent au deuxième essai. Deux échouent trois fois parce que la grille n’a pas de ligne pour ces produits; elles aboutissent sur une courte liste pour une personne, qui découvre que deux produits ont été discontinués. Pendant ce temps, l’échec d’arrondi est revenu assez souvent pour que la consigne gagne une règle, « recopie les prix exactement, n’arrondis jamais », de sorte qu’un lot suivant commence avec la leçon déjà intégrée. Rien n’est mis en ligne avant qu’une personne lise le résumé et approuve la fusion. Remarquez ce que la personne n’a pas fait : lire 40 pages. Les barrières les ont lues. La personne a consacré son temps aux deux cas qui demandaient du jugement et à la seule décision qui pouvait nuire à l’entreprise. > **À essayer :** choisissez une tâche que vous faites déjà avec l’IA. Notez une seule vérification qui pourrait refuser le résultat sans que vous le lisiez, puis donnez-lui un résultat volontairement mauvais et confirmez qu’elle dit non. Si vous ne trouvez aucune vérification de ce genre, cette tâche n’est pas prête pour une boucle. Si vous voulez de l’aide pour découper un de vos propres travaux en unités et en vérifications, ce prompt est un bon point de départ : ```prompt Voici un travail que je veux confier à l’IA : [décris le travail et ce que veut dire « terminé »]. 1. Découpe-le en unités qui peuvent chacune être vérifiées seules. 2. Pour chaque unité, nomme une vérification qui peut la refuser sans qu’une personne la lise, et dis quelle preuve cette vérification renverrait en cas d’échec. 3. Indique quelles étapes peuvent être défaites facilement et lesquelles ne le peuvent pas. 4. Dis-moi où une personne devrait approuver, et pourquoi, selon les dégâts qu’une erreur pourrait causer. Ne propose pas « demander au modèle s’il a raison » comme vérification. ``` Le reste de la section, dans l’ordre de lecture : [ce qui rend une vérification réelle](/fr/apprendre/verification-reelle-boucle-ia/), [comment créer une boucle avec une vraie barrière](/fr/apprendre/creer-boucle-ia-vraie-barriere/), [comment concevoir un graphe d’agents](/fr/apprendre/concevoir-graphe-agents-ia/), [où une personne devrait approuver](/fr/apprendre/ou-approuver-boucle-ia/), et deux études de cas : [les chercheurs d’alignement automatisés d’Anthropic](/fr/apprendre/chercheurs-alignement-automatises-anthropic/), une grande boucle dont les vérifications refusaient le travail sans que personne surveille et dont les agents ont parfois tenté de tricher, et [le guide d’octobre 2026 sur l’intégration des sous-agents dans une seule boucle](/fr/apprendre/une-boucle-agent-ou-sous-agents/). Pour une première boucle d’agent écrite à la main, voyez [Comment créer une boucle d’agent simple avec l’API d’OpenAI?](/fr/apprendre/boucle-agent-simple-api-openai/). ## Faut-il un cadriciel pour construire des boucles et des graphes? Non. Une boucle, c’est une boucle `for` avec une vérification et une limite, et un petit graphe, c’est quelques fonctions appelées dans l’ordre, avec une liste d’unités au milieu. L’article pratique de cette section n’utilise rien d’autre que la bibliothèque standard de Python. Commencer en simple code a un vrai avantage : vous voyez chaque vérification et chaque arête, et rien ne se passe que vous n’ayez écrit. Un cadriciel commence à valoir la peine quand vous avez besoin de ce que le simple code rend fastidieux : sauvegarder l’état d’une longue exécution pour qu’elle reprenne après une panne ou une pause humaine, faire rouler beaucoup d’exécutants en parallèle et fusionner leurs résultats, ou revenir à un point sauvegardé antérieur d’une exécution pour voir où elle a déraillé. La documentation de LangGraph couvre ces trois besoins, avec des points de sauvegarde (*checkpoints*), `Send` pour la répartition et des interruptions pour l’approbation humaine, et elle plafonne aussi le nombre d’étapes d’une exécution, une version intégrée de la limite de tentatives. Quel que soit votre choix, les pièces qui rendent le système digne de confiance sont les mêmes et ne viennent pas du cadriciel : des vérifications capables de refuser le travail, une limite de tentatives, des unités refusées renvoyées une à une avec leurs preuves, et une personne à l’étape où une erreur coûterait cher. ## Sources - Building effective agents: https://www.anthropic.com/engineering/building-effective-agents - Graph API overview (LangGraph docs source): https://github.com/langchain-ai/docs/blob/7aee47ad2fe0f18f297fa8f3d96598dc5d27dfa3/src/oss/langgraph/graph-api.mdx - Harness design for long-running application development: https://www.anthropic.com/research/harness-design-long-running-apps - Reflexion: Language Agents with Verbal Reinforcement Learning: https://arxiv.org/abs/2303.11366v4 - How we built our multi-agent research system: https://www.anthropic.com/engineering/multi-agent-research-system - Interrupts (LangGraph docs source): https://github.com/langchain-ai/docs/blob/4a11da593fc9c0b0dd170a068170ed9443585c48/src/oss/langgraph/interrupts.mdx --- Tiré du Guide de l’intelligence artificielle, par Robert Scales, publié par Holistic Hybrid inc. Partage et adaptation permis selon la licence CC BY-NC-SA 4.0 (https://creativecommons.org/licenses/by-nc-sa/4.0/) : citez le guide, mettez un lien vers https://guidetoartificialintelligence.com/fr/apprendre/boucles-et-graphes-ia-expliques/, pas d’usage commercial sans permission, et gardez la même licence.