Architecture
Pattern de coordination multi-agents où un orchestrateur décompose le travail en sous-tâches, les agents spécialistes tirent de et poussent vers un store d'état partagé, et l'orchestrateur compose la réponse finale depuis cet état partagé. Les configurations multi-agents semblent cohérentes au lieu que chaque assistant ait sa propre mémoire inconsistante.
Orchestrator {
n1: circle label="Complex task arrives"
n2: rectangle label="Request shared context"
n3: rectangle label="Create research subtask"
n4: rectangle label="Create action subtask"
n5: rectangle label="Receive findings and results"
n6: rectangle label="Compile final answer"
n1.handle(right) -> n2.handle(left)
n2.handle(bottom) -> SharedMemory.n7.handle(top) [label="Read state"]
n3.handle(right) -> n4.handle(left)
n3.handle(bottom) -> Researcher.n9.handle(top) [label="Research task"]
n4.handle(bottom) -> Operator.n13.handle(top) [label="Action task"]
n5.handle(right) -> n6.handle(left)
Researcher.n12.handle(top) -> n5.handle(left) [label="Finding"]
Operator.n17.handle(top) -> n5.handle(right) [label="Result"]
}
Researcher {
n9: rectangle label="Receive research task"
n10: rectangle label="Read shared memory"
n11: rectangle label="Analyze with context"
n12: rectangle label="Return finding"
n9.handle(right) -> n10.handle(left)
n10.handle(right) -> n11.handle(left)
n11.handle(right) -> n12.handle(left)
n10.handle(bottom) -> SharedMemory.n7.handle(left) [label="Read state"]
}
Operator {
n13: rectangle label="Receive action task"
n14: rectangle label="Read shared memory"
n15: rectangle label="Execute with context"
n16: rectangle label="Write result to memory"
n17: rectangle label="Return result"
n13.handle(right) -> n14.handle(left)
n14.handle(right) -> n15.handle(left)
n15.handle(right) -> n16.handle(left)
n16.handle(bottom) -> SharedMemory.n8.handle(left) [label="Write state"]
n15.handle(bottom) -> n17.handle(top)
}
SharedMemory {
n7: rectangle label="Resolve memory request"
n8: rectangle label="Update shared state"
n7.handle(right) -> n8.handle(left)
}
Architecture
Une architecture multi-agents superviseur-travailleur où un agent orchestrateur reçoit un objectif de haut niveau, le décompose en sous-tâches, délègue chacune à des agents travailleurs spécialisés (chercheur, rédacteur, QA), surveille l'exécution, gère les échecs et synthétise les résultats. L'orchestrateur gère mais n'exécute pas les tâches lui-même.
Architecture
Une architecture orchestrateur-travailleur où un agent orchestrateur décompose un objectif en sous-tâches, les distribue à des travailleurs spécialisés, puis synthétise une réponse finale. C'est l'architecture 'orchestration d'agents' la plus courante—puissante mais l'orchestrateur peut devenir un goulot d'étranglement à mesure que le nombre de travailleurs augmente.
Architecture
Une architecture multi-agents hiérarchique qui scalde l'orchestration en empilant superviseurs et chefs d'équipe (une structure arborescente), ce qui reflète les structures organisationnelles d'entreprise et aide à partitionner le contexte. C'est l'architecture 'IA agentique de niveau entreprise' quand un seul orchestrateur ne peut pas gérer tous les travailleurs directement.
Architecture
Une architecture compétitive / générateur-critique où plusieurs générateurs produisent des réponses indépendantes, puis un agent évaluateur note et sélectionne la meilleure sortie. Cette approche améliore la qualité et réduit la fragilité d'un modèle unique. C'est plus coûteux (plusieurs appels LLM) mais rentable quand la correction ou la créativité compte plus que la latence.
Architecture
Une architecture multi-agents pipeline séquentiel où les agents sont arrangés dans une séquence stricte. Chaque agent transforme ou enrichit la sortie du précédent, puis la passe au suivant. Pas d'orchestrateur central — le flux est déterministe comme une chaîne d'assemblage.
Architecture
Une architecture multi-agents essaim où plusieurs agents travaillent simultanément sur les mêmes tâches ou des tâches connexes, sans coordinateur central. Leurs sorties sont ensuite agrégées, votées ou fusionnées par un nœud agrégateur dédié. Les agents peuvent rivaliser — la meilleure sortie gagne.