Prompt Chaining
Aussi appelé : pipeline, workflow séquentiel, chaîne, sequential orchestration (Microsoft), linear delegation (Azure Architecture Center), deterministic flow (OpenAI Agents SDK), SequentialAgent ou sequential process (Google ADK, CrewAI)
Intention
Découper une tâche difficile en une suite fixe d'appels LLM plus petits et d'étapes de code ordinaire. Chaque étape reçoit une consigne étroite et la sortie de l'étape précédente, et du code peut vérifier le résultat entre deux étapes avant que la suite ne s'exécute.
L'ordre des étapes est écrit par le développeur. Le modèle ne décide jamais de ce qui s'exécute ensuite.
Problème
Une entreprise veut une note de risques en français pour chaque contrat fournisseur qu'elle reçoit en anglais. L'équipe juridique lit le français ; les contrats font environ 40 pages.
La première version est un seul prompt : « lis ce contrat, trouve les clauses risquées, note-les, rédige une note en français selon notre modèle ». Cela fonctionne sur certains contrats. Sur d'autres, cela échoue d'une manière difficile à voir :
- Des étapes sont sautées. Le modèle poursuit cinq objectifs à la fois et en abandonne certains. Des clauses disparaissent de la note sans que personne ne s'en aperçoive.
- Des détails inventés. Des numéros de clause absents du contrat apparaissent, et il n'existe aucune liste intermédiaire pour les vérifier.
- Des consignes perdues dans un long prompt. Certaines notes sortent en anglais parce que la règle de langue se trouve à la fin d'un long prompt.
- Impossible de localiser la partie fautive. Quand une note est fausse, vous ne savez pas si c'est l'extraction, la notation, la rédaction ou la traduction qui a échoué. Le seul test possible est de bout en bout.
- Une seule configuration pour tout. La traduction se contenterait d'un petit modèle bon marché et la notation des risques demande le plus puissant, mais un appel unique n'a qu'un seul modèle.
- Le processus est simulé. Si vous demandez à un seul prompt de « rédiger, critiquer, puis améliorer », le modèle peut écrire volontairement un brouillon faible pour le « corriger » ensuite. Sun et al. (2024) appellent cela simulated refinement, et le présentent comme une explication probable plutôt que démontrée.
Solution
Coupez la tâche là où la nature du travail change, donnez à chaque morceau son propre prompt court, et exécutez les morceaux dans un ordre fixé dans le code. Entre deux étapes, du code parse la sortie et la vérifie. Une vérification en échec peut relancer l'étape, arrêter la chaîne ou confier le cas à une personne. L'article d'Anthropic « Building effective agents » appelle ces vérifications des gates (ici, des portes) et présente le prompt chaining comme le premier workflow, et le plus simple.
Pour la note de risques, la chaîne compte cinq étapes :
- Extraire. Un petit modèle liste les clauses en JSON :
[{id, title, text}]. Porte : le JSON se parse et contient au moins une clause. - Classer. Un modèle puissant note chaque clause faible, moyen ou élevé selon une grille. Porte : chaque id de clause de l'étape 1 est présent et chaque note est l'une des trois valeurs.
- Rédiger. La note est rédigée en anglais à partir des seuls éléments à risque élevé ou moyen.
- Traduire. Un modèle bon marché la traduit en français. Porte : un détecteur de langue indique le français.
- Mettre en forme. Du code ordinaire place le texte dans le modèle de document juridique. Aucun appel LLM.
Chaque étape est assez petite pour être bien promptée, testée seule et déboguée. Quand une note est fausse, les résultats intermédiaires stockés montrent quelle étape a échoué.
Qui décide du déroulement : le développeur, à la conception. Le modèle écrit le contenu de chaque étape et produit au plus une valeur lue par une porte. Il ne choisit jamais l'étape suivante. C'est ce qui en fait un workflow et non un agent. Dans Plan-and-Execute, un LLM écrit la liste des étapes à l'exécution ; dans Orchestrator–Workers, un modèle principal invente les sous-tâches à chaque requête. Ici, la liste est dans votre code.
Analogie
Une rédaction de journal. Le reporter rend son article, le vérificateur contrôle les noms et les chiffres, le secrétaire de rédaction corrige le style, le traducteur produit l'édition étrangère, et la mise en page le place sur la page. L'ordre des postes est fixé par le rédacteur en chef, pas par les personnes à chaque poste. Le vérificateur joue le rôle de porte : un article avec un chiffre faux retourne au reporter au lieu de passer à la suite.
L'analogie s'arrête au jugement. Un secrétaire de rédaction humain qui remarque qu'un paragraphe manque le signale. Une étape LLM travaille en général avec ce qu'on lui donne et continue, d'où la nécessité de portes explicites dans une chaîne, et l'intérêt de montrer la source d'origine à chaque étape qui a besoin de la vérité de terrain.
Structure
- Étape. Une transformation ciblée : un modèle de prompt, un modèle de langage avec ses réglages, et un parseur qui transforme le texte brut en valeur typée. Une étape peut aussi être du code ordinaire ou un agent complet qui utilise des outils.
- Porte. Du code, ou un appel à un classifieur bon marché lu par du code, qui vérifie la valeur parsée : schéma, décomptes, expression régulière, règle métier. Elle renvoie validation, nouvel essai, réparation, sortie anticipée ou escalade.
- Contrat de passage. Exactement ce que reçoit l'étape suivante : la sortie précédente, et l'entrée d'origine ou des résultats antérieurs seulement si nécessaire. Trop peu fait perdre de l'information ; trop alourdit le prompt.
- Étape de code. Un travail déterministe comme la mise en forme, une requête en base de données ou l'exécution de tests. Moins cher et plus facile à tester qu'un appel LLM.
- Sortie anticipée. Un arrêt maîtrisé quand une porte échoue à répétition ou que l'entrée sort du périmètre : une erreur, une réponse de repli ou une personne.
- État et trace. Les résultats intermédiaires sont stockés par nom, pour que les exécutions puissent être inspectées, mises en cache et reprises, avec un span de trace par étape (prompt, sortie, tokens, latence, verdict de la porte). Le runner qui appelle les étapes dans l'ordre se résume souvent à une boucle
for.
Générateur de prompt
Décrivez l'objectif et listez les étapes dans l'ordre. Pour chaque étape, indiquez sa tâche unique, son format de sortie et la vérification qui s'exécute après elle. Mettez code comme modèle pour les étapes qui n'ont pas besoin de LLM. Le résultat comporte deux parties : des règles pour le code du runner (nouveaux essais, sortie anticipée, budget, traces), puis un prompt par étape LLM avec ses balises d'entrée. Collez les prompts des étapes dans votre propre runner, un nœud LangGraph ou les étapes séquentielles de n'importe quel framework.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.
La plupart des défaillances d'une chaîne se produisent aux passages : un JSON mal formé, une clause perdue, un champ dont l'étape suivante avait besoin. Placez une vérification de code peu coûteuse juste après les étapes d'extraction et de planification, car leurs erreurs se propagent à tout ce qui suit. Gardez une référence en un seul prompt et ne conservez que les étapes qui font mieux qu'elle sur votre jeu d'évaluation.
Quand l'utiliser
À utiliser quand
- La tâche se découpe en étapes fixes connues à l'avance. C'est le critère principal d'Anthropic. L'ordre ne doit pas dépendre de ce que vous découvrez en chemin.
- Vous devez inspecter les résultats intermédiaires. Pour un audit, la conformité ou le débogage. La documentation actuelle de Claude sur le prompting indique que le chaînage explicite reste utile même avec des modèles de raisonnement puissants, quand il faut inspecter les sorties intermédiaires ou imposer une structure de pipeline.
- Les étapes demandent des modèles, des réglages ou des outils différents. Un petit modèle pour l'extraction et la traduction, un modèle puissant pour la notation des risques.
- Certains résultats intermédiaires peuvent être vérifiés par du code. Schémas, décomptes, tests, détection de langue. C'est de ces vérifications que vient la fiabilité.
- La prévisibilité compte et un peu de latence en plus est acceptable. Anthropic décrit ce compromis comme de la latence échangée contre de la précision. Utilisateurs et régulateurs voient le même chemin à chaque fois.
À éviter quand
- Un seul prompt bien écrit passe déjà votre évaluation. Chaque étape supplémentaire ajoute un aller-retour et des tokens. Gardez l'appel unique.
- Les étapes ne dépendent pas les unes des autres. Exécutez-les en même temps avec Parallelization.
- Le type d'entrée détermine le pipeline à exécuter. Placez un Routing devant plusieurs chaînes.
- Vous avez besoin de « recommencer jusqu'à ce que ce soit assez bon ». C'est une boucle avec un plafond explicite : Evaluator–Optimizer.
- Le nombre et la nature des étapes dépendent de ce qui est trouvé. Une recherche ouverte ou du code sur plusieurs fichiers relèvent de ReAct, Plan-and-Execute ou Orchestrator–Workers.
- Les étapes doivent revenir en arrière ou discuter. Le guide Azure cite le retour arrière, le routage dynamique et la collaboration comme raisons d'éviter l'orchestration séquentielle. Utilisez un graphe avec des arêtes de retour, Swarm / Handoffs ou Group Chat.
- La latence est critique, comme dans un chat en temps réel. Utilisez moins d'appels mais plus gros, des étapes parallèles, ou ne streamez que la dernière étape.
La frontière bouge dans les deux sens. Si vous ajoutez sans cesse des branches pour des cas imprévus, ou si les portes échouent souvent parce que les entrées varient plus que les étapes ne le supposent, une étape (ou toute la chaîne) devrait devenir un agent. Un compromis courant garde la chaîne extérieure et fait d'une étape un agent. Si les traces montrent qu'un agent suit presque toujours le même chemin, figez ce chemin dans le code : la documentation de l'OpenAI Agents SDK indique qu'orchestrer par le code est plus prévisible en vitesse, en coût et en performance.
Mise en œuvre
- Écrivez d'abord la référence en un seul prompt. La chaîne doit faire mieux qu'elle sur un jeu d'évaluation pour justifier son coût.
- Trouvez les points de découpe. Les bons endroits sont ceux où le type de sortie change (texte, puis données, puis prose), où une compétence différente est nécessaire (extraction, raisonnement, style, traduction), où la justesse est facile à vérifier, ou où un autre modèle convient mieux.
- Définissez un contrat de données pour chaque passage. Utilisez une sortie structurée (JSON schema, Pydantic) pour tout ce que lit du code. N'utilisez du texte libre que lorsque le consommateur suivant est un autre LLM, et entourez alors chaque résultat amont de sa propre balise XML (
<outline>,<draft>) pour que le prompt suivant puisse y faire référence par son nom. - Écrivez un prompt étroit par étape. Indiquez son objectif unique, son format d'entrée et de sortie, et ce qu'il ne faut pas faire (« ne traduis pas encore »).
- Ajoutez des portes là où les erreurs sont faciles à détecter et coûteuses à laisser passer. Juste après les étapes d'extraction et de planification. En cas d'échec, relancez en renvoyant le message d'erreur.
- Fixez des règles de nouvel essai et d'arrêt. Un nombre maximal d'essais par étape, un budget total en tokens ou en coût, et un timeout par appel et par chaîne. Séparez les nouveaux essais liés au transport (limites de débit) de ceux liés à une mauvaise sortie.
- Choisissez un modèle par étape. De petits modèles pour la classification, l'extraction et la mise en forme, des modèles puissants pour le raisonnement et la synthèse (recommandations de coût de l'Azure Architecture Center).
- Tracez et testez chaque étape séparément, puis de bout en bout. Persistez l'état après chaque étape pour qu'un plantage reprenne au lieu de tout recommencer.
- Mettez en cache les étapes déterministes ou répétées, par nom d'étape, version du prompt, modèle et hash de l'entrée.
Un framework est facultatif. Le cookbook d'Anthropic implémente tout le pattern comme une boucle qui ajoute le résultat précédent au prompt suivant (son exemple transforme en quatre étapes un rapport de performance désordonné en tableau markdown), et Anthropic prévient que les abstractions des frameworks peuvent masquer les prompts et les réponses. Les frameworks d'agents emballent la même idée sous le nom d'« orchestration séquentielle d'agents » ; si une étape n'a besoin ni d'outils ni de plusieurs tours, un simple appel LLM coûte moins cher et se teste plus facilement.
| Framework | Forme que prend ce pattern |
|---|---|
| API brute | Une boucle for sur les prompts ; les portes sont vos propres instructions if. |
| LangChain (LCEL) | prompt | model | parser construit une RunnableSequence ; .with_retry(), .with_fallbacks(), with_structured_output. Le streaming de bout en bout ne fonctionne que si chaque composant le prend en charge. |
| LangGraph | StateGraph avec add_edge pour la ligne et add_conditional_edges pour une porte ; état partagé typé. |
| OpenAI Agents SDK | Plusieurs appels Runner.run dans le code, un agent vérificateur avec output_type, un if pour la porte, le tout dans trace(). |
| Google ADK | SequentialAgent(sub_agents=[...]) avec output_key et le templating {key}. Désormais marqué comme obsolète au profit du graphe Workflow d'ADK 2.0. |
| CrewAI | Process.sequential ; context=[...] sélectionne des tâches antérieures ; guardrail avec guardrail_max_retries (3 par défaut). |
| Semantic Kernel | SequentialOrchestration(members=[...]) ; marqué expérimental, absent du SDK Java. |
| Microsoft Agent Framework | SequentialBuilder ; transmet toute la conversation par défaut, chain_only_agent_responses=True ne transmet que la réponse précédente ; impossible de revenir à un agent antérieur. |
| DSPy | Un module dont la méthode forward() appelle des sous-modules dans l'ordre ; un compilateur ajuste les prompts de chaque étape selon une métrique. |
| LlamaIndex Workflows | Des méthodes @step reliées par des événements typés, de StartEvent à StopEvent. |
Mise en garde. Ces API évoluent vite. La documentation de Google ADK marque SequentialAgent comme obsolète sans version ni date de retrait, l'orchestration d'agents de Semantic Kernel est expérimentale et Microsoft Agent Framework semble lui succéder, et l'API d'assertions de DSPy a changé d'une version à l'autre (noms actuels non vérifiés). Les frameworks de graphes sont la voie d'évolution habituelle : une chaîne est un graphe linéaire, une arête conditionnelle en fait du routage, et une arête de retour en fait une boucle.
Variantes
Chaîne linéaire
A, puis B, puis C, sans vérification. La boucle chain() du cookbook ou un pipe LCEL. Suffisant pour des prototypes et des transformations à faible enjeu.
Chaîne avec portes
Des vérifications en code entre les étapes décident de la validation, d'un nouvel essai ou d'une sortie anticipée. L'exemple de deterministic flow d'OpenAI s'arrête simplement quand le vérificateur de plan juge le plan médiocre ou hors genre. Une porte qui arrête l'exécution avec une raison claire fait son travail.
Chaîne hybride (étapes LLM et étapes de code)
Certaines étapes sont du parsing, de la recherche documentaire, des requêtes en base, l'exécution de tests ou de la mise en forme. Decomposed Prompting (Khot et al., 2023) permet qu'une sous-tâche soit un prompt, un modèle entraîné ou une fonction symbolique. L'étape de mise en forme de l'exemple du contrat en est une.
Extraire, transformer, générer
Une entrée non structurée devient des données structurées, puis des données traitées, puis de la prose. Les pipelines documentaires prennent cette forme. DocETL réécrit de tels pipelines en chaînes plus fines et annonce des sorties 25 à 80 % plus précises que des références bien conçues sur quatre tâches (Shankar et al., 2024, résultats déclarés par les auteurs).
Rédiger, critiquer, améliorer
Une chaîne fixe en trois étapes : générer, relire selon des critères, réécrire une fois. La documentation de Claude sur le prompting la désigne comme le pattern de chaînage le plus courant. Si l'étape d'amélioration boucle jusqu'à ce qu'un critère soit satisfait, elle devient un Evaluator–Optimizer.
Chaîne avec boucles intégrées (« flow engineering »)
Un pipeline essentiellement linéaire dont certaines étapes itèrent contre des tests. AlphaCodium exécute une chaîne de prétraitement linéaire (réfléchir au problème, raisonner sur les tests, proposer et classer des solutions, générer des tests supplémentaires), puis corrige le code contre les tests. La boucle de correction est elle-même une boucle évaluateur–optimiseur.
Chaîne par élément
La même chaîne s'exécute sur chaque document ou clause, souvent en parallèle, puis une étape de réduction fusionne les résultats. Le fan-out relève de Parallelization ; chaque voie est une chaîne.
Chaîne avec points de contrôle humains
Une pause après une étape pour approbation ou modification, par exemple avant l'envoi de la note. Microsoft Agent Framework propose with_request_info ; LangGraph propose des interrupts. Voir Human-in-the-Loop.
Chaîne d'agents
Chaque étape est un agent complet avec ses outils et sa propre boucle, et l'ordre entre les agents reste fixe. C'est ce que Semantic Kernel, ADK et CrewAI appellent l'orchestration séquentielle. À l'intérieur de chaque étape, voir ReAct.
Chaîne compilée
Les prompts et les exemples few-shot de chaque étape sont ajustés automatiquement selon une métrique. DSPy le fait avec un compilateur appliqué à des modules composés dans forward().
Chaîne générée
Un LLM écrit une fois la liste des étapes, puis du code l'exécute comme une chaîne fixe. C'est Plan-and-Execute.
Avantages et inconvénients
Avantages
- En général plus précis, car chaque appel traite une tâche plus facile. AlphaCodium (un flux en plusieurs étapes, résultats déclarés par les auteurs) a fait passer le pass@5 de GPT-4 sur son jeu de validation CodeContests de 19 % à 44 %.
- Chaque résultat intermédiaire peut être journalisé, testé unitairement et rejoué. Dans l'étude utilisateurs d'AI Chains (Wu et al., 2022, 20 participants), les participants déboguaient en testant des étapes isolées et ont jugé le chaînage meilleur en transparence et en contrôle.
- Chaque étape peut avoir son propre modèle, sa température et ses outils, si bien que la plupart des étapes peuvent tourner sur un modèle bon marché.
- Le même chemin s'exécute à chaque fois, ce qui rend le coût et la latence prévisibles et les audits possibles.
- Les étapes peuvent être mises en cache, et les longs préfixes communs peuvent profiter du prompt caching.
- Aucun framework nécessaire : le runner tient en quelques lignes de code.
Inconvénients
- Latence plus élevée : la somme de toutes les étapes, plus le parsing et les nouveaux essais, sans parallélisme dans une chaîne stricte.
- En général plus de tokens au total : consignes répétées, contexte répété, nouveaux essais. AlphaCodium utilise environ 15 à 20 appels LLM par solution.
- Les erreurs s'accumulent si les portes ne les arrêtent pas. Simple calcul, pas une mesure : si chacune de 5 étapes indépendantes réussit 95 % du temps, la chaîne réussit environ 77 % du temps ; avec 10 étapes, environ 60 %.
- Rigide : les entrées qui ne correspondent pas aux étapes prévues produisent des résultats absurdes.
- Les étapes sont couplées : changer le format de sortie d'une étape peut casser le parseur de la suivante.
Ce calcul d'accumulation suppose des échecs indépendants, alors que les échecs réels sont corrélés. Il joue aussi dans l'autre sens : chaque étape plus petite est plus facile, donc son taux de réussite dépasse celui du prompt unique, et une porte avec nouveaux essais l'augmente encore. Le but est d'avoir des étapes faciles et vérifiables, pas le moins d'étapes possible.
L'essentiel des preuves vient de modèles sortis avant l'extended thinking intégré (LaMDA dans AI Chains, GPT-4 dans AlphaCodium et chez Sun et al.). Les sources ne contiennent aucune comparaison contrôlée récente entre une chaîne et un appel unique à un modèle de raisonnement : considérez l'ampleur des gains comme dépendante du modèle et mesurez-la sur votre propre tâche.
Modes de défaillance
- Erreurs en cascade
-
Une extraction erronée au début empoisonne toutes les étapes suivantes. Dans la chaîne du contrat, une clause manquée à l'étape 1 n'atteint jamais la note, et la note reste pourtant agréable à lire.
Parade : des portes juste après les premières étapes ; des vérifications contre des données dont la justesse est connue (les « test anchors » d'AlphaCodium empêchent un test généré erroné d'annuler une correction qui passait les tests connus) ; laisser une personne corriger les sorties intermédiaires.
- Perte d'information
-
Une étape ultérieure a besoin d'un détail qu'une étape précédente a supprimé ou résumé, comme au téléphone arabe. L'étape de rédaction connaît la note de risque mais pas la formulation exacte de la clause.
Parade : transmettre l'entrée d'origine ou le résultat antérieur quand une étape a besoin de la vérité de terrain ; stocker les gros artefacts et transmettre des références ; tester avec des entrées qui contiennent des détails rares.
- Contexte qui gonfle
-
Transmettre tout l'historique à chaque étape rend les prompts longs, lents, coûteux et source de distraction.
Parade : des contrats de passage minimaux ; résumer ou élaguer entre les étapes. Les sources ne sont pas d'accord sur ce point : Cognition soutient que lorsque les étapes sont des agents de longue durée qui font des choix implicites, des passages étroits perdent ces choix. Pour des appels LLM courts et bien spécifiés, des contrats minimaux fonctionnent bien.
- Dérive de format et erreurs de parsing
-
Le modèle entoure le JSON de prose ou oublie un champ, et l'étape suivante plante ou, pire, continue avec la moitié des données.
Parade : la sortie structurée native, une validation de schéma avec l'erreur renvoyée lors du nouvel essai (comme le fait Instructor), des parseurs stricts qui échouent bruyamment, du YAML au lieu du JSON quand la sortie contient du code (le choix d'AlphaCodium : pas d'échappement des guillemets, moins de tokens).
- Portes mal calibrées
-
Trop strictes, elles provoquent des essais sans fin et de faux rejets. Trop laxistes, elles laissent passer les erreurs. Une porte confiée à un LLM juge a son propre taux d'erreur.
Parade : préférer les vérifications en code ; mesurer pour chaque porte les taux de fausses validations et de faux rejets sur des exemples étiquetés ; plafonner les essais ; journaliser chaque verdict et examiner les cas rejetés.
- Sur-découpage
-
De nombreuses étapes minuscules ajoutent de la latence et du coût, et chaque passage est une occasion de perdre de l'information.
Parade : fusionner les étapes qui n'échouent jamais seules. Ne garder une étape que si elle améliore une métrique d'évaluation ou rend une vérification possible.
- Processus simulé
-
Un seul prompt à qui l'on demande de « rédiger, puis critiquer, puis améliorer » se contente de faire semblant. Sun et al. (2024) ont constaté que trois prompts séparés faisaient mieux qu'un prompt combiné pour le résumé, même si le prompt combiné écrivait de meilleures critiques : la séparation semble surtout compter pour les étapes de génération.
Parade : faire de chaque phase un appel séparé.
- Entrées qui ne correspondent pas aux étapes
-
Un document sans section de clauses, ou un contrat en allemand, traverse quand même la chaîne et produit un résultat absurde.
Parade : une porte de classification de l'entrée au début, avec sortie anticipée ou Routing vers une autre chaîne.
- Régressions silencieuses
-
Modifier un prompt change la distribution de ses sorties et casse discrètement une étape ultérieure.
Parade : versionner les prompts et les contrats ; des tests d'assertion par étape sur des échantillons réels, relancés à chaque modification du pipeline ; une évaluation de bout en bout à chaque changement.
- Tempêtes de nouveaux essais
-
Les nouveaux essais à chaque étape multiplient les appels, et les nouveaux essais liés au transport s'ajoutent à ceux de validation.
Parade : des budgets par étape et globaux en tokens, en temps et en argent ; une seule couche de nouveaux essais pour les erreurs de transport, pas deux (désactivez les retries du SDK si un wrapper relance déjà).
- Erreurs masquées
-
Une étape renvoie une valeur vide ou fictive et les étapes suivantes continuent.
Parade : faire remonter les erreurs au lieu de les cacher ; prévoir un champ « unknown » explicite dans les contrats ; des portes qui rejettent les valeurs vides.
- Instructions injectées qui descendent la chaîne
-
Le texte du contrat (ou un résultat d'outil) contient des instructions, et une étape ultérieure leur obéit.
Parade : entourer les sorties amont de balises et dire à chaque étape qu'il s'agit de données ; appliquer des contrôles de contenu à plusieurs endroits, pas seulement à la fin ; donner à chaque étape le moins d'outils possible.
- Longues chaînes interrompues
-
Un plantage ou un déploiement en cours de chaîne fait perdre tout le travail déjà effectué.
Parade : persister l'état après chaque étape (checkpointers de LangGraph ou d'Agent Framework), rendre les étapes idempotentes, reprendre à la dernière étape terminée.
Liens avec les autres patterns
- Routing : un classifieur choisit quelle chaîne, quel prompt ou quel modèle s'exécute, et se place souvent devant plusieurs chaînes. Une porte qui continue ou sort est un routeur minuscule, mais l'ordre d'une chaîne ne dépend jamais du type d'entrée.
- Parallelization : exécute en même temps des étapes indépendantes, là où une chaîne exécute des étapes dépendantes l'une après l'autre. Les deux se combinent souvent : appliquer une chaîne à de nombreux éléments en parallèle, puis réduire.
- Evaluator–Optimizer : une boucle de génération et d'évaluation qui se répète jusqu'à ce qu'un critère soit satisfait. Rédiger, critiquer, améliorer en est un passage déroulé, et un nouvel essai plafonné après une porte est le plus petit pas dans sa direction.
- ReAct (tool-use loop) : le modèle choisit l'action suivante à chaque tour. Utilisez-le dans une étape de la chaîne qui demande un usage ouvert des outils, ou à la place de la chaîne quand les étapes ne peuvent pas être connues à l'avance.
- Plan-and-Execute : souvent confondu avec le chaînage. Là, un LLM écrit la liste des étapes à l'exécution, puis les étapes s'exécutent, souvent sous forme de chaîne. Ici, c'est le développeur qui écrit la liste.
- Orchestrator–Workers : un modèle principal décide des sous-tâches à chaque requête et les confie à des workers (exécutants). Dans une chaîne, les étapes sont fixées à la conception.
- Supervisor : un agent central choisit quel worker agit après chaque étape. L'étape suivante d'une chaîne est fixée dans le code ; la « sequential orchestration » des frameworks d'agents est la forme en chaîne des mêmes agents.
- Hierarchical teams : une chaîne peut être une équipe au sein d'une hiérarchie. Beaucoup de systèmes « entreprise » fondés sur des rôles sont surtout des chaînes avec des intitulés de poste.
- Swarm / Handoffs : l'agent actif décide qui passe ensuite, l'inverse d'un ordre fixe. Microsoft recommande les handoffs quand un pipeline séquentiel doit revenir à un agent antérieur ou interroger l'utilisateur.
- Group Chat : les agents partagent une même transcription et un sélecteur choisit le prochain intervenant. Les « chat chains » à la ChatDev sont des pipelines dont les étapes sont de petites conversations.
- Blackboard : faire passer l'état entre des étapes fixes par des clés nommées est l'usage le plus léger d'un stockage partagé, sans le contrôle opportuniste du blackboard.
- Council / Debate : plusieurs agents répondent à la même question et réagissent les uns aux autres. Utilisez-le à la place d'une chaîne quand les étapes doivent débattre plutôt que se passer le relais.
- Human-in-the-Loop : des points de contrôle d'approbation ou de modification entre les étapes. Une personne peut remplacer ou doubler une porte programmatique.
Pour aller plus loin
Toutes les sources ci-dessous sont en anglais.
- Building effective agents (Anthropic, 2024) : la définition du prompt chaining et des portes, workflows contre agents, et le conseil de commencer simple.
- basic_workflows.ipynb (cookbook d'Anthropic) : la boucle
chain()minimale et un exemple de traitement de données en quatre étapes. - AI agent orchestration patterns (Azure Architecture Center) : l'orchestration séquentielle et quand l'éviter, la gestion du contexte, des recommandations de fiabilité et de coût.
- AI Chains: Transparent and Controllable Human-AI Interaction by Chaining LLM Prompts (Wu, Terry, Cai, CHI 2022) : une taxonomie des étapes élémentaires et une étude utilisateurs, y compris sur les erreurs en cascade.
- Prompt Chaining or Stepwise Prompt? Refinement in Text Summarization (Sun et al., ACL Findings 2024) : des appels séparés face à un prompt combiné, et l'hypothèse du simulated refinement.
- Code Generation with AlphaCodium: From Prompt Engineering to Flow Engineering (Ridnik, Kredo, Friedman, 2024) : un flux de code en plusieurs étapes avec sortie YAML et test anchors.