Architecture multi-agents 2026 :
des design patterns à la production

Douleurs : un agent monolithique bute sur des goulots structurels — pas par faiblesse du modèle.

• Plafond de contexte : les résultats intermédiaires remplissent la fenêtre ; la qualité de raisonnement chute ensuite.
• Dilution des compétences : un agent pour la recherche, le code et la revue — tout est moyen.
• Exécution séquentielle : sous-tâches en série ; durée totale = somme des étapes.
• Point de défaillance unique : un agent en erreur bloque toute la chaîne.

Un système multi-agents (MAS) réunit plusieurs agents IA indépendants via des protocoles et une orchestration explicites. Chaque agent doit être spécialisé par rôle, disposer d'accès outils, maintenir un état isolé et rester remplaçable.

Conclusion AdaptOrch : la façon d'organiser la collaboration des agents influence le résultat plus que le choix du modèle de base.

Pattern 1 — Pipeline séquentiel : la sortie de A alimente B ; flux strictement linéaire. Pour dépendances fixes (rédaction, revue de code). LangGraph : StateGraph retriever → analyzer → writer ; durée = somme des étapes ; comportement prévisible et auditable.

from langgraph.graph import StateGraph, START, END

builder = StateGraph(PipelineState)
builder.add_node("retriever", retrieval_agent)
builder.add_node("analyzer", analysis_agent)
builder.add_node("writer", writer_agent)
builder.add_edge(START, "retriever")
builder.add_edge("retriever", "analyzer")
builder.add_edge("analyzer", "writer")
builder.add_edge("writer", END)
pipeline = builder.compile()

Pattern 2 — Fan-out / fan-in parallèle : sous-tâches indépendantes en parallèle ; nœud de fusion. Durée = max(T1, T2, …, Tn). LangGraph Send API renvoie des listes d'objets Send ; Annotated[list, operator.add] comme reducer agrège sans verrous manuels.

Pattern 3 — Supervisor-Worker hiérarchique : supervisor pour intent, découpage et routage ; workers pour tâches métier ; synthesizer pour synthèse. Recommandé : routage à deux niveaux — voie rapide par mots-clés (<1 ms, sans LLM) + routage LLM pour intents flous.

Pattern 4 — Swarm / réseau : peer-to-peer sans coordinateur central ; arrêt par rounds, consensus ou timeout. Pour débats multi-tours ; en production, prudence — AutoGen GroupChat exige un max_round strict.

Pattern 5 — Blackboard : espace de travail structuré partagé ; agents lisent/écrivent quand les prérequis sont remplis, sans planificateur explicite. Pour workflows asynchrones de plusieurs heures/jours et équipes hétérogènes.

Pattern 6 — Hybride : combinaison de patterns — typiquement routage d'intent + supervisor + recherche parallèle + pipeline QA + revue humaine. Contenu entreprise : requêtes simples en direct, rapports complexes via supervisor → recherche parallèle → revue → publication.

Choix : fiabilité production, persistance d'état, HITL fin → LangGraph ; validation d'idée en 1–2 jours → CrewAI ; Microsoft/Azure, débats itératifs → AutoGen.

Architecture protocolaire à deux couches (2026, Linux Foundation AAIF) :

• MCP (couche verticale) : agent ↔ outils/BD/API. Piloté par Anthropic ; écrire une fois, réutiliser partout.
• A2A (couche horizontale) : agent ↔ agent. Open source Google avril 2025, v1.0 début 2026 ; 50+ partenaires. Délégation standardisée, découverte de capacités, sync d'état ; chaque agent publie /.well-known/agent.json ; orchestrateur délègue via JSON-RPC 2.0 message/send.

Pour les équipes UE : les outils MCP peuvent traiter des données CRM ou tickets ; les traces A2A entre services peuvent transiter par des régions cloud US. Documentez registre de traitement, sous-traitance et transferts — central pour la conformité RGPD en production multi-agents.

card = await httpx.get(f"{agent_url}/.well-known/agent.json")
skills = [s["id"] for s in card.json()["skills"]]
payload = {"jsonrpc": "2.0", "method": "message/send", ...}
response = await httpx.post(agent_card["url"], json=payload)

Quatre piliers de production :

• Persistance et reprise : LangGraph PostgresSaver comme checkpoint ; thread_id cross-process ; redémarrage sans perte.
• Human-in-the-Loop : interrupt() suspend les actions à risque (ex. écriture prod DB) jusqu'à validation.
• Circuit breaker et retry : seuil → OPEN ; après timeout HALF_OPEN ; toujours wrapper les appels agents externes.
• Budget tokens : TokenBudgetManager avant chaque appel ; BudgetExceededException ; suivi par agent.

Observabilité (analyse MAST sur 1642 traces) :

57 % des organisations ont des agents en production, seulement 8 % ont déployé l'observabilité LLM — erreurs en HTTP 200, dashboards au vert. Réponse : OpenTelemetry avec correlation_id, métriques clés (succès >85 %, P95 <30 s, taux d'erreur agent <5 %), LLM-as-a-Judge pour complétude et hallucinations. Les traces peuvent contenir des prompts personnels — définir rétention et accès sous RGPD.

• Pollution de contexte : hallucination de A atteint B et C ; HTTP 200 quand même. Parade : validation de schéma aux passations, confiance <0,7 refusée, champs obligatoires.
• Boucles infinies et coûts : spirales retry/outils. Parade : MAX_ITERATIONS=10, MAX_TOOL_CALLS_PER_AGENT=20, MAX_TOTAL_TOKENS=50_000 ; interrupt_before avant outils coûteux.
• Sur-ingénierie : chaîne en deux étapes éclatée en huit agents. Règle : commencer par pipeline ; en production, souvent 3 à 8 agents.
• Écart démo-production : entrées limites en cascade. Parade : ProductionGuardrails — limite longueur, injection de prompt, filtre PII, classification contenu nocif.
• Sync branches parallèles (LangGraph) : branches Send de longueurs différentes ; supervisor relance trop tôt. Parade : builder.add_node("supervisor", supervisor_node, defer=True).

Arbre de décision : dépendance linéaire stricte → parallélisable ? Non → pipeline ; Oui → fan-out + pipeline. Pas de linéarité → autorité décisionnelle ? Oui → sous-équipes ? Non → supervisor-worker ; Oui → supervisor hiérarchique. Pas d'autorité → async longue ? Oui → blackboard ; Non → agents ≤5 avec arrêt clair ? Oui → swarm avec limite de rounds ; Non → restructurer en hiérarchie.

Tendances 2026 : orchestration fédérée, multi-agents multimodaux, topologie adaptive (AdaptOrch), EU AI Act avec chaîne d'audit complète — lié à la traçabilité RGPD.

• Google Agent Bake-Off (MLflow 2026) : architecture multi-agents distribuée de 1 heure à 10 minutes — plus de 6× plus rapide.
• AdaptOrch (arXiv 2602.16873) : bonne topologie apporte 12–23 % sur SWE-bench — plus que le choix de modèle.
• MAST : 1642 traces — design système 41,77 %, désalignement 36,94 % ; 57 % en production, 8 % observabilité.
• A2A v1.0 (2026) : 50+ partenaires entreprise ; JSON-RPC 2.0 over HTTP ; Agent Card comme standard de facto.

Documentation officielle (revérifier les liens après release) :

https://langchain-ai.github.io/langgraph/

https://docs.crewai.com

https://microsoft.github.io/autogen/

https://modelcontextprotocol.io

https://github.com/google/A2A

1. Valider par pipeline : LangGraph ou CrewAI — chaîne 3 étapes (retrieval → analyse → sortie) ; n'étendre que si un agent unique échoue vraiment.
2. Choisir topologie et framework : arbre de décision ; conformité (finance/santé) → LangGraph ; prototype rapide → CrewAI ; Azure → AutoGen.
3. Couche outils MCP et A2A : MCP Server par worker ; cross-service via Agent Card + JSON-RPC.
4. Renforcer les guardrails : checkpoints Postgres, budget tokens, circuit breaker, schéma aux passations, limites de boucles strictes.
5. Déployer l'observabilité : OpenTelemetry, alertes métriques, échantillonnage LLM-as-Judge ; cible succès >85 %.
6. Déployer 24/7 : la veille du laptop casse les workflows longs ; un VPS Linux seul manque sandbox macOS et Xcode. Pour orchestration multi-agents stable, infra MCP et CI iOS, la location Mac bare-metal CALMVPS est souvent supérieure : M4/M4 Pro dédié, provisioning ~120 s, facturation jour/semaine/mois/trimestre flexible — levier RGPD et souveraineté des données vs API cloud US pures. Voir tarifs et centre d'aide.

L'architecture multi-agents ne consiste pas à empiler des agents, mais à choisir la topologie, connecter les protocoles et instrumenter l'observabilité. MCP + A2A sont le standard ; l'orchestration prime sur le modèle — commencez par un pipeline à trois nœuds et étendez avec preuves.