>Orchestration multi-agents: composer des agents spécialisés

Un agent, ça fait des merveilles. Cinq agents qui collaborent, c’est soit un bon groupe de métal, soit le bordel. Tout dépend de l’orchestration.
Depuis que j’ai montré comment construire un agent qui crée ses propres outils, je passe beaucoup de temps à me demander pourquoi un seul agent, même bon, ne suffit pas. La réponse en 2026 est devenue claire: les modèles se sont rapprochés au point que le choix du modèle importe moins que la façon dont on assemble les agents. La question n’est plus quel est le meilleur agent, mais quelle est la meilleure division du travail?.
Pourquoi plusieurs agents au lieu d’un seul?
Un agent monolithique a un problème structurel: il doit tout faire avec un seul contexte, une seule mémoire, une seule politique. Il est fort partout et parfait nulle part, et son coût explose parce que chaque appel transporte le contexte entier.
La spécialisation change la donne. Un agent de test n’a pas besoin de connaître l’architecture du déploiement. Un agent de review n’a pas besoin de la couche réseau. Chacun garde un contexte court, une politique stricte, et un coût maîtrisé.
Trois bénéfices concrets:
- Contexte court: chaque agent voit peu, donc chaque appel est rapide et pas cher.
- Politique par rôle: l’agent qui écrit le code n’a pas le droit de merge (c’est une extension de mes réflexions sur le threat modeling).
- Modèles adaptés: un SLM suffit pour le résumé, un gros modèle répond au décisionnel (je l’ai détaillé dans l’article sur les petits modèles locaux).
Les patterns d’orchestration
Il y a quatre manières classiques d’organiser des agents, chacune avec ses forces et ses pièges.
1. Pattern Superviseur
Un agent chef reçoit la tâche, la découpe, délègue aux sub-agents, récupère les résultats et synthétise. C’est le pattern le plus simple et le plus courant.
Le superviseur est un vrai goulot d’étranglement cognitif: tout passe par lui. Il doit découper correctement, traiter les retours, détecter les échecs partiels. C’est aussi le point de contrôle idéal pour bloquer une action, ce qui en fait le siège de la politique de sécurité.
2. Pattern pipeline
Chaque agent ne fait qu’une étape et transmet son résultat au suivant. Pensez à une chaîne de montage.
Simple à gérer, chaque étape a une entrée et une sortie claires. Mais une erreur en amont contamine toute la suite, et il n’y a pas de retour en arrière sans intervention du superviseur au-dessus.
3. Pattern tableau noir
Le blackboard: des agents spécialisés écrivent dans un espace partagé et y lisent les contributions des autres, sans se connaître directement. C’est le pattern de choix pour les systèmes complexes, et le plus dur à déboguer.
4. Pattern équipe libre
Les agents se parlent directement et négocient. C’est cool, c’est aussi le meilleur moyen d’obtenir des discussions à répétition, un coût incontrôlé et de l’imprévisibilité. Je l’évite en production.
Mon conseil: le superviseur pour 90% des cas, le pipeline pour les flux bien définis, et on s’arrête là. Les deux autres patterns sont des réponses à des problèmes que vous n’aurez que rarement.
Contre-exemple: un orchestrateur de release
Concrètement, voici comment j’orchestre une release avec trois agents spécialisés. Contrainte forte: aucun agent ne peut merger. L’orchestrateur est le seul à signer la release.
// orchestrateur.ts |
Le point important n’est pas le code, c’est la frontière de droits. Le codeAgent a peut-être accès à l’écriture, le reviewAgent n’a que la lecture, et l’action de merge n’existe que dans le superviseur. Si l’agent de review est compromis (par une prompt injection), il peut démolir la review mais pas pousser son code.
Partager l’état, pas les secrets
Comment les agents partagent-ils l’état sans se partager les privilèges?
J’ai structuré ça en une règle unique. Chaque agent reçoit:
- un contexte (le diff, le ticket, les logs: de la donnée),
- une politique (quels outils, quels droits: de l’autorisation),
- et rien d’autre.
Les secrets (jetons API, credentials de base) ne transitent jamais dans le message. C’est l’orchestrateur qui les injecte dans les appels d’outils au moment de l’exécution, exactement comme la couche dont je parlais dans mon article sur les secrets d’agents.
// chaque agent reçoit sa politique, pas ses credentials |
Et quand deux agents échangent, l’orchestrateur tronque le contexte à peine reçu: si l’agent code produit un output de 10000 tokens, l’agent review aura un résumé, pas le paquet complet. Le contexte des agents reste petit par design, et les coûts restent proportionnés aux besoins.
Le coût caché de l’orchestration
Orchestrer coûte cher en complexité.
- Latence: chaque étape ajoute un aller-retour de modèle. Une chaîne de 4 agents = 4+ appels séquentiels.
- Cumul d’erreurs: chaque agent propage ses propres erreurs, et le superviseur doit savoir faire la part des choses.
- Debug: quand ça merde, est-ce l’agent de test, le contexte, l’orchestrateur ou la politique? Le diagnostic multi-couche, c’est le cas que je connais bien, et il est plus dur qu’avec un seul agent.
- Coût: deux agents valent plus cher qu’un seul s’ils font deux fois la même chose. La spécialisation ne paie que si elle réduit réellement le contexte et le travail.
La règle d’or: ne découpez que si le contexte, la politique ou la compétence diffèrent réellement. Découper pour découper, c’est déployer un pipeline pour un problème qui se résout avec une fonction.
Le verdict
La multi-agents n’est pas une affaire de quantité d’agents, c’est une affaire de frontières. Les agents spécialisés gagnent quand la séparation du contexte et des droits a un vrai avantage: moins de tokens, moins de risques, des politiques fines. Et le superviseur centralise ce qui ne doit jamais être décentralisé: les décisions qui engagent.
L’infrastructure de cette orchestration, côté exécution, c’est du CI/CD. Une fois que les agents tournent en boucle sur votre code, le pipeline qui les exécute devient le nouveau point de contrôle.