Parallelization
Aussi appelé : fan-out / fan-in, scatter-gather, concurrent orchestration (Microsoft), parallel agent (Google ADK), sectioning, voting, self-consistency, best-of-N, map-reduce
Intention
Lancer plusieurs appels LLM en même temps sur des morceaux de travail qui ne dépendent pas les uns des autres, puis combiner leurs sorties en une seule étape d'agrégation. Les branches sont soit des sous-tâches différentes (sectioning, découpage en sections), soit la même tâche exécutée plusieurs fois (voting, vote). Votre code fixe le découpage avant le début de l'exécution : c'est ce qui distingue ce pattern d'un orchestrateur qui invente les sous-tâches en cours de route.
Problème
Vous construisez un outil d'audit d'acquisition (due diligence) pour une petite équipe d'investissement. Une analyste charge la data room d'Acme Robotics (documents sociaux, trois ans d'états financiers, les principaux contrats clients, une étude de marché) et demande : Acme est-elle une cible d'acquisition raisonnable ?
L'outil a besoin d'une revue juridique, d'une revue financière et d'une revue de marché. Aucune n'a besoin du résultat des autres. Les premières versions de l'outil échouent de trois façons :
- Un seul prompt fait les trois travaux. Le modèle doit, dans la même passe, chercher les clauses de changement de contrôle dans les contrats, vérifier les chiffres de revenus et juger les concurrents. Chaque sujet reçoit moins d'attention. Anthropic indique qu'un appel par sujet fonctionne en général mieux qu'un appel qui en jongle plusieurs (une heuristique issue de l'expérience, pas un chiffre publié).
- Trois appels lancés l'un après l'autre. Chaque revue a son propre prompt, mais le code les attend en séquence. Si chacune prend environ 20 secondes, l'analyste attend une minute pour un travail qui pourrait se terminer en 20 secondes environ, plus une courte fusion.
- Un seul échantillon, accepté sans contrôle. Quand un appel unique lit mal une clause, rien ne le détecte, et vous n'avez aucun signal sur le degré de confiance de la réponse.
Solution
Écrivez le découpage dans le code. Lancez un appel LLM par morceau indépendant, tous en même temps, attendez-les à une barrière, puis remettez tous les résultats à un agrégateur. Chaque branche ne voit que son propre prompt et l'entrée partagée ; les branches ne communiquent jamais entre elles pendant l'exécution.
- Découper. Le code construit la liste des tâches de branche :
legal_review,financial_review,market_review, chacune avec son prompt ciblé et la même data room. - Fan-out. Les trois appels démarrent ensemble, sous un plafond de concurrence et avec un timeout par branche.
- Travail des branches. Chaque relecteur renvoie du JSON selon un schéma connu : une liste de constats avec gravité et preuves.
- Fan-in. Une barrière attend que toutes les branches aient terminé, qu'un quorum soit atteint ou qu'une échéance soit dépassée. Les branches en échec sont enregistrées, pas masquées.
- Agréger. Un LLM fusionne les trois rapports en une synthèse des risques. Il conserve chaque risque distinct, indique quel relecteur l'a soulevé, expose les désaccords et marque une revue manquante comme « non disponible ».
- Renvoyer le rapport avec ses métadonnées : quelles branches ont réussi, et si le résultat est dégradé.
C'est le sectioning : une sous-tâche différente dans chaque branche. La seconde variante, le voting, exécute la même tâche plusieurs fois et agrège les réponses. Dans le même outil, trois relecteurs pourraient chacun lire les contrats clients à la recherche de clauses de changement de contrôle, et le code signalerait une clause dès que l'un d'eux la rapporte. Les deux termes viennent de « Building effective agents », d'Anthropic.
Qui décide du flux : le développeur. Le code fixe la façon de découper, le nombre de branches, les prompts et les modèles, les limites et la règle d'agrégation. Les LLM ne décident que du contenu de chaque branche et, éventuellement, du texte fusionné. Dans Orchestrator–Workers, le fan-out a la même forme, mais un LLM principal décide à l'exécution combien de sous-tâches existent et ce que couvre chacune.
Analogie
Un acheteur sur le point d'acquérir un immeuble envoie le même dossier à un avocat, un expert-comptable et un géomètre le lundi matin. Ils travaillent dans des bureaux séparés et ne s'appellent jamais. Le vendredi, l'acheteur lit les trois rapports côte à côte et rédige une note de décision. L'acheteur a choisi les trois experts avant d'envoyer quoi que ce soit : c'est le découpage décidé par le développeur. La note de décision, c'est l'agrégateur.
Pour le vote, imaginez demander à deux experts en bâtiment leur avis sur la toiture et agir si l'un des deux trouve un dégât. L'analogie s'arrête au coût : les experts humains sont lents et chers, alors qu'une branche LLM de plus coûte peu par appel, mais multiplie votre facture de tokens et la pression sur vos limites de débit.
Structure
- Répartiteur. Du code qui transforme l'entrée en liste de tâches de branche et garantit qu'elles sont indépendantes. En map-reduce, c'est un découpeur de texte qui crée une tâche par fragment.
- Branches. Un appel LLM (ou un agent complet avec ses outils) par sous-tâche ou par échantillon. Chacune reçoit son propre prompt et renvoie un résultat selon un schéma connu. Un ordonnanceur les lance ensemble et applique le plafond de concurrence, les timeouts et les nouvelles tentatives.
- Barrière de fan-in. Attend toutes les branches, un quorum, une échéance, ou une sortie anticipée comme le déclenchement d'un garde-fou. Elle enregistre quelles branches ont échoué.
- Agrégateur. Transforme N sorties en une seule : une fonction pure (concaténation, union, vote, seuil k sur N) ou un LLM (synthèse, sélection). Choisissez la règle avant d'écrire les prompts, car elle détermine le schéma de sortie.
- Résultat avec métadonnées. La réponse fusionnée, plus
branches_ok,branches_failed,degradedet, pour le vote, le décompte des voix et la marge.
Générateur de prompt
Décrivez l'entrée partagée et une ligne par branche. La sortie comporte quatre parties : une spécification d'exécution pour votre code de fan-out (limites, politique d'échec, règle d'agrégation), le bloc d'entrée partagée, un prompt par branche, et le prompt ou la règle de l'agrégateur. Utilisez-les avec un simple asyncio.gather, un fan-out LangGraph ou l'étape parallèle de n'importe quel framework.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.
L'essentiel du travail porte sur les contrats d'interface, plus que sur la formulation. Donnez aux branches des périmètres qui ne se recouvrent pas, faites renvoyer à chaque branche du JSON typé, et décidez d'abord de la règle d'agrégation. Un prompt de synthèse nourri de N dissertations libres, c'est là que les détails se perdent ; un vote sur un champ final_answer normalisé est facile à réussir.
Quand l'utiliser
À utiliser quand
- Les sous-tâches sont réellement indépendantes. Aucune branche n'a besoin de la sortie d'une autre et l'ordre n'a pas d'importance. Le guide de Microsoft parle de travail « embarrassingly parallel ».
- La latence compte et les branches prennent un temps comparable. Le temps réel devient celui de la branche la plus lente plus l'agrégation, au lieu de la somme.
- Un seul prompt jongle avec plusieurs sujets. Une vérification de garde-fou à côté de la réponse principale, ou un évaluateur par critère d'évaluation, obtiennent chacun toute l'attention du modèle.
- Vous avez besoin de fiabilité ou d'un signal de confiance. Le vote fonctionne quand les réponses ont une forme comparable (libellés, nombres, options, code avec tests), et la marge du vote vous dit quel degré de certitude accorder.
- Vous voulez plusieurs « paires d'yeux » avec un seuil réglable. Revue de sécurité ou modération, où vous arbitrez entre faux positifs et faux négatifs en choisissant k.
- L'entrée dépasse la fenêtre de contexte et chaque fragment peut être traité sans les autres (map-reduce).
À éviter quand
- Les étapes dépendent les unes des autres. Utilisez Prompt Chaining pour ce lien.
- Vous ne pouvez pas lister les sous-tâches à l'avance. Laissez un modèle décider avec Orchestrator–Workers ou Plan-and-Execute.
- Les branches écriraient dans le même état ou le même système externe. Sans coordination, elles s'écrasent mutuellement. Gardez les écritures dans l'agrégateur ou après lui.
- Vous n'avez pas de règle pour les résultats contradictoires. Si vous ne savez pas dire comment fusionner, la fusion sera arbitraire.
- Les limites de débit ou le budget sont serrés. Le vote multiplie le coût à peu près linéairement avec N, et un seul bon appel peut déjà suffire.
- Les erreurs sont corrélées. Si tous les échantillons partagent la même idée fausse, plus de votes ajoutent du coût mais peu de précision.
Mise en œuvre
- Prouvez l'indépendance. Dessinez le graphe de dépendances des sous-tâches. Toute arête entre deux d'entre elles est une chaîne, pas une branche.
- Choisissez la variante. Des sujets différents : sectioning. La même question avec un besoin de fiabilité : voting. Une entrée trop grande ou de nombreux éléments : map-reduce.
- Définissez une sortie structurée par branche. Incluez un
branch_idstable, unstatus(ok,error,timeout,invalid), la charge utile et, pour le vote, unfinal_answernormalisé. - Choisissez la règle d'agrégation avant les prompts. Concaténation, union et dédoublonnage, vote majoritaire, seuil k sur N, best-of-N avec un vérificateur, ou synthèse par LLM. La règle détermine le schéma.
- Fixez des limites. Un plafond de concurrence sous la limite de débit de votre fournisseur, un timeout par branche, une échéance globale, des nouvelles tentatives avec backoff sur HTTP 429, et une politique d'échec : tout ou rien, au mieux avec un indicateur
degraded, ou quorum. - Triez avant de fusionner. L'ordre de complétion n'est pas stable (LangGraph et Semantic Kernel le précisent tous les deux) : triez donc les résultats par
branch_idet utilisez une règle de départage fixe. - Tracez sous un seul span parent, avec un span enfant par branche, pour voir les N appels côte à côte. L'exemple de parallélisation d'OpenAI regroupe toutes les exécutions dans une seule trace.
- Mesurez par rapport à un appel unique de référence sur la précision, la latence p50/p95 et le coût par tâche avant de garder les branches supplémentaires. Retirez une branche à la fois pour vérifier que chacune justifie son coût.
En Python pur, le cœur est un asyncio.gather sur les appels de branche, enveloppés dans un sémaphore et asyncio.wait_for. La plupart des frameworks proposent une primitive nommée pour la même chose :
| Framework | Fan-out | Fan-in |
|---|---|---|
| LangGraph | Plusieurs arêtes depuis un nœud ; Send pour un map dynamique | Reducers sur les clés d'état ; arête sous forme de liste add_edge(["a","b"], "merge") ; defer=True |
| LangChain (LCEL) | RunnableParallel ; batch avec max_concurrency | Un dict indexé par nom de branche |
| OpenAI Agents SDK | asyncio.gather sur Runner.run | Votre code, ou un agent sélecteur |
| Google ADK | ParallelAgent(sub_agents=[...]) | Un output_key distinct par branche dans l'état de session, puis un agent de fusion |
| CrewAI | Task(async_execution=True) | Une tâche ultérieure avec context=[...] |
| LlamaIndex Workflows | send_event plusieurs fois ; num_workers | collect_events |
| Microsoft Agent Framework | ConcurrentBuilder, AddFanOutEdge | Agrégateur par défaut ou personnalisé ; AddFanInBarrierEdge |
| Semantic Kernel | ConcurrentOrchestration | Liste de résultats, ordre non garanti |
Deux comportements de LangGraph sont bons à connaître. Un superstep est transactionnel : si une branche parallèle lève une exception, aucune des mises à jour d'état de cette étape n'est appliquée, et une RetryPolicy ne relance que la branche en échec. Une arête sous forme de liste ne se déclenche jamais, sans aucun avertissement, si l'un des nœuds listés ne s'exécute pas.
Mise en garde. Ces API évoluent vite. Google ADK marque les workflow agents à gabarit, ParallelAgent compris, comme dépréciés au profit des workflows à base de graphe, sans date de suppression annoncée. L'API d'orchestration de Semantic Kernel est expérimentale. Vérifiez les noms dans la documentation actuelle.
Variantes
Sectioning
Une liste fixe d'appels différents, comme dans l'exemple suivi. Les exemples d'Anthropic sont un garde-fou qui tourne à côté de la réponse principale et des évaluations automatisées où chaque appel note un aspect (fidélité, ton, exhaustivité).
Garde-fous en parallèle
Un cas de sectioning où une branche peut opposer son veto à l'autre. L'OpenAI Agents SDK exécute par défaut les garde-fous d'entrée en même temps que l'agent, et propose un mode bloquant. Le compromis qu'il documente : en mode parallèle, l'agent peut déjà avoir dépensé des tokens et lancé des outils avant que le garde-fou ne se déclenche. Ne lancez jamais d'outils à effets de bord dans une branche qu'un garde-fou parallèle peut encore annuler.
Vote et self-consistency
Le même prompt, N échantillons à une température supérieure à zéro, un vote majoritaire sur la réponse extraite. Wang et al. ont échantillonné 40 chemins de raisonnement et rapporté +17,9 points sur GSM8K par rapport à un chain-of-thought simple, mais l'essentiel du gain arrivait dès 5 à 10 chemins. Dans leur comparaison des méthodes d'agrégation, un vote majoritaire simple (74,4 %) égalait la meilleure variante pondérée, tandis qu'une pondération par les probabilités non normalisées du modèle tombait à 59,9 %. Ces résultats portent sur des modèles de 2022 ; les gains sur les modèles actuels sont probablement plus faibles sur les benchmarks saturés. La méthode exige des réponses issues d'un ensemble fixe.
Perturbation du prompt et de l'entrée
Faites varier le prompt au lieu de la température, ou en plus. L'ensemble à mélange des choix de Medprompt lance 5 appels avec les options de QCM dans un ordre différent et retient la réponse la plus fréquente ; il a apporté environ 2,2 points dans l'ablation des auteurs. Le mélange contrebalance aussi le biais de position.
Panels multi-modèles
Des modèles différents répondent ou jugent, puis votent. Dans l'étude PoLL, un panel de petits juges issus de familles de modèles différentes a battu un seul grand juge pour un coût plus de sept fois inférieur, avec moins de biais d'auto-préférence. Dès que les juges se lisent et se critiquent les uns les autres, on passe à Council / Debate.
Universal self-consistency
Pour les sorties en texte libre, où un vote à correspondance exacte est impossible, un LLM lit tous les candidats et choisit celui qui est le plus cohérent avec les autres. L'article indique que la méthode égale la self-consistency standard en mathématiques et le vote fondé sur l'exécution pour le code.
Best-of-N avec un vérificateur
Générez N candidats et gardez celui qu'un vérificateur note le plus haut : tests unitaires, vérificateur entraîné ou juge LLM. Avec un vérificateur automatique, cela passe très bien à l'échelle : dans « Large Language Monkeys », le taux de résolution sur SWE-bench Lite passe de 15,9 % avec un échantillon à 56 % avec 250. Sans vérificateur fiable, la sélection plafonne au-delà de quelques centaines d'échantillons.
Map-reduce
Le nombre de branches vient des données (fragments, fichiers, lignes), mais l'opération par branche est fixe. Quand les résumés produits par le map restent trop longs pour un seul appel de reduce, une étape de compactage les réduit par groupes. Bornez cette boucle : l'exemple de LangChain utilise une limite de récursion de 10.
Skeleton-of-Thought
Le modèle écrit d'abord un plan court, puis chaque point est développé en parallèle. L'article rapporte des accélérations jusqu'à 2,39x, avec une qualité qui tient sur les questions de connaissances et de sens commun, mais qui baisse en mathématiques, en code et en rédaction. Le plan est généré à l'exécution, ce qui rapproche cette variante d'Orchestrator–Workers.
Appels d'outils en parallèle
Le modèle émet plusieurs appels d'outils dans un même tour et votre code les exécute en même temps. Ici, c'est le modèle qui décide du fan-out : cette variante se situe donc entre ce pattern et la boucle ReAct. La documentation de Claude exige tous les résultats d'outils dans un seul message utilisateur ; les répartir sur plusieurs messages apprend au modèle à ne plus appeler d'outils en parallèle.
Avantages et inconvénients
Avantages
- Le temps réel tombe à celui de la branche la plus lente plus la fusion quand les sous-tâches sont indépendantes.
- Chaque branche a un prompt court et ciblé, et les branches simples peuvent utiliser un modèle plus petit.
- Le vote améliore la précision sur les réponses de forme fixe et fournit gratuitement un signal de confiance (la marge du vote).
- Le flux est fixé dans le code : il est prévisible, facile à tester branche par branche, et peu coûteux comparé aux patterns à base d'agents.
- Un seuil k sur N permet d'arbitrer entre rappel et précision sans toucher aux prompts.
Inconvénients
- Environ N fois les tokens d'un appel, plus l'agrégation. Le vote ne réduit pas la latence ; il ajoute l'échantillon le plus lent et l'agrégateur.
- N requêtes simultanées atteignent plus vite les limites de débit.
- Plus d'appels, c'est plus de risques d'échec par exécution : il vous faut des timeouts, des nouvelles tentatives et une politique d'échec.
- L'étape d'agrégation est un problème de conception à part entière, et un LLM de synthèse peut perdre des détails ou inventer un accord.
- L'ordre de complétion aléatoire et l'échantillonnage rendent les exécutions difficiles à reproduire, sauf si vous triez et fixez les règles de départage.
Modes de défaillance
- Dépendance cachée
-
La revue financière avait besoin d'un fait trouvé par la revue juridique (par exemple, un contrat qui prend fin en cas de changement de contrôle). Les deux rapports se contredisent et la fusion ne peut pas dire pourquoi.
Parade : dessinez le graphe de dépendances avant de construire ; enchaînez les étapes dépendantes au lieu de les paralléliser.
- Tempête de limites de débit
-
Toutes les branches partent en même temps, beaucoup reçoivent un HTTP 429, et des nouvelles tentatives naïves aggravent la rafale.
Parade : un sémaphore sous la limite du fournisseur, un backoff exponentiel avec jitter, ou le
max_concurrency/num_workersdu framework. - Branche retardataire
-
Une branche lente fixe la latence totale. Anthropic note que dans son système de recherche, l'agent principal attend ses sous-agents de façon synchrone, si bien qu'un sous-agent lent bloque toute l'étape.
Parade : un timeout par branche, une échéance globale ou un quorum, et un résultat marqué comme dégradé.
- Échec partiel silencieux
-
Une branche échoue et l'agrégateur fusionne le reste comme si de rien n'était. Le rapport n'a pas de section marché, ou un vote est biaisé par les échantillons manquants.
Parade : une politique explicite (tout ou rien, au mieux avec un indicateur
degraded, ou quorum) et une consigne à l'agrégateur d'écrire « non disponible » pour les parties manquantes. - Effets de bord avant le déclenchement d'un garde-fou
-
La branche principale a déjà dépensé des tokens ou appelé un outil au moment où le garde-fou parallèle bloque la requête.
Parade : tenez les outils à effets de bord hors de la branche principale tant que le garde-fou n'a pas répondu, ou utilisez le mode bloquant.
- Conflits d'état partagé
-
Deux branches écrivent la même clé ou le même enregistrement, et l'une écrase l'autre. Microsoft classe l'état mutable partagé entre agents concurrents parmi les anti-patterns.
Parade : une clé de sortie distincte par branche, des reducers qui fusionnent les écritures concurrentes, et des écritures uniquement dans l'agrégateur.
- Erreurs d'extraction des réponses
-
« 42 », « 42.0 » et « quarante-deux » comptent comme trois votes différents, et des sorties impossibles à parser se glissent dans le décompte.
Parade : demandez un champ
final_answernormalisé, normalisez avant de compter, et comptez à part les sorties impossibles à parser. - Erreurs corrélées
-
Tous les échantillons partagent le même biais, et la majorité se trompe avec assurance.
Parade : diversifiez les branches (prompts différents, options mélangées, familles de modèles différentes) et utilisez un vérificateur exécutable quand c'est possible.
- Trop de votes
-
Chen et al. montrent que, sur des tâches de difficulté hétérogène, la précision peut monter puis baisser à mesure que les appels augmentent, car les appels supplémentaires aident sur les requêtes faciles et nuisent sur les difficiles.
Parade : faites varier N sur un jeu de développement (par exemple 1, 3, 5, 10) et tracez la précision en fonction du coût au lieu de maximiser N.
- Agrégateur surchargé
-
L'appel de synthèse reçoit N longs rapports, dépasse sa fenêtre de contexte ou perd des détails.
Parade : des sorties de branche structurées et de longueur plafonnée, et un reduce hiérarchique quand les branches sont nombreuses.
Liens avec les autres patterns
- Prompt Chaining : le pendant séquentiel, pour les étapes qui dépendent les unes des autres. Les deux se combinent souvent : prétraitement en chaîne, fan-out, fusion.
- Routing : un classifieur choisit une branche par entrée ; la parallélisation en exécute plusieurs. Le routage multi-étiquette se situe entre les deux, en choisissant vers quelles branches faire le fan-out.
- Evaluator–Optimizer : affine une réponse en séquence. Best-of-N en est le cousin parallèle, et un vote à coût égal est la référence qu'une boucle d'affinage doit battre.
- ReAct (tool-use loop) : les appels d'outils en parallèle sont un fan-out local à l'intérieur de cette boucle, décidé par le modèle plutôt que par le développeur.
- Plan-and-Execute : les planificateurs en DAG comme LLMCompiler exécutent en parallèle les étapes planifiées indépendantes ; c'est le plan, et non votre code, qui définit les branches.
- Orchestrator–Workers : même forme de fan-out et de fan-in, mais un LLM principal décide des sous-tâches à l'exécution. Le
Sendde LangGraph sert aux deux ; la différence tient à qui a écrit la liste, le code ou un LLM. - Supervisor : quand un superviseur appelle plusieurs workers en un seul saut, ce saut est un petit fan-out parallèle dont le superviseur est l'agrégateur.
- Hierarchical teams : un chef d'équipe exécute souvent ses workers en parallèle.
- Council / Debate : les membres voient les réponses des autres et y réagissent avant une décision. Le vote garde les échantillons indépendants ; le tour 0 d'un council est un fan-out parallèle, et un vote à coût égal est sa référence.
- Blackboard : des branches qui écrivent des clés distinctes dans un état partagé forment un blackboard léger ; un vrai blackboard a des agents qui réagissent aux écritures des autres.
- Human-in-the-Loop : une faible marge de vote ou des sections contradictoires sont des moments naturels pour consulter une personne.
Pour aller plus loin
Toutes les sources sont en anglais.
- Building effective agents (Anthropic) : définit la parallélisation, le sectioning et le voting, avec les exemples de garde-fou, d'évaluation et de revue de code.
- AI agent orchestration patterns (Microsoft Azure Architecture Center) : l'orchestration concurrente, quand l'éviter, les stratégies d'agrégation et des conseils de fiabilité.
- Self-Consistency Improves Chain of Thought Reasoning in Language Models (Wang et al.) : la méthode de vote et sa comparaison des méthodes d'agrégation.
- Are More LLM Calls All You Need? (Chen et al.) : pourquoi plus de votes peut faire baisser la précision, et comment choisir le nombre d'appels.
- Guardrails (OpenAI Agents SDK) : garde-fous parallèles ou bloquants, et le compromis sur les effets de bord.
- Graph API control flow (LangGraph) : supersteps, reducers, nœuds différés et erreurs transactionnelles dans les branches parallèles.