Systèmes multi-agents

Systèmes multi-agents#

Dans les chapitres précédents, nous avons étudié les agents LLM individuels et les frameworks qui les soutiennent. Un agent seul, aussi performant soit-il, reste limité par sa perspective unique, ses biais de raisonnement et sa capacité à gérer des tâches complexes comportant de multiples facettes. Les systèmes multi-agents (multi-agent systems, MAS) proposent une approche fondamentalement différente : plutôt que de confier une tâche entière à un seul agent, on la répartit entre plusieurs agents spécialisés qui collaborent, débattent et se corrigent mutuellement.

L’idée n’est pas nouvelle en intelligence artificielle — les systèmes multi-agents classiques remontent aux années 1980 — mais l’émergence des LLM leur donne une dimension inédite. Chaque agent dispose désormais d’une capacité de raisonnement en langue naturelle, ce qui permet des formes de communication et de coordination auparavant réservées aux equipes humaines. Un agent peut critiquer le raisonnement d’un autre, proposer une reformulation, ou synthétiser des perspectives divergentes, le tout dans un échange textuel structure.

Ce chapitre présente les architectures multi-agents fondamentales — séquentielle, parallèle, hiérarchique et de débat — ainsi que les mécanismes de communication et de coordination qui les sous-tendent. Nous illustrerons chaque architecture par des simulations en Python pur, sans dépendance à un framework d’agents particulier, afin de comprendre les mécanismes internes avant de les appliquer en pratique.

Pourquoi des systèmes multi-agents ?#

Les tâches complexes du monde réel dépassent souvent les capacités d’un agent unique. Rédiger un rapport technique, par exemple, exige à la fois une expertise du domaine, une capacité de vérification des faits, une rigueur stylistique et une cohérence d’ensemble. Un seul LLM, même puissant, tend à produire des erreurs non détectées, des biais de confirmation et des hallucinations. En répartissant ces responsabilités entre des agents spécialisés — un rédacteur, un vérificateur, un éditeur — on reproduit la dynamique d’une équipe humaine performante.

Définition 72 (Système multi-agents)

Un système multi-agents (MAS) est un ensemble \(\mathcal{A} = \{A_1, A_2, \ldots, A_n\}\) d’agents autonomes qui intéragissent dans un environnement partagé \(\mathcal{E}\) via un protocole de communication \(\mathcal{P}\). Chaque agent \(A_i\) possède :

  • un rôle \(r_i\) (prompt système définissant sa spécialisation),

  • un état interne \(s_i\) (mémoire de travail, contexte accumulé),

  • une politique \(\pi_i(a \mid s_i, m)\) qui determine son action \(a\) en fonction de son état et des messages reçus \(m\).

Le système produit une sortie collective \(y = f(A_1, \ldots, A_n, \mathcal{P})\) qui, idéalement, est supérieure à ce que tout agent individuel pourrait seul.

Les avantages d’un système multi-agents sont multiples. La spécialisation permet à chaque agent de se concentrer sur un sous-problème précis, réduisant la charge cognitive et améliorant la qualité. La vérification croisée permet de détecter des erreurs qu’un agent seul ne remarquerait pas. La diversité des perspectives réduit les biais systématiques. Enfin, la décomposition des tâches complexes en sous-tâches indépendantes permet un traitement plus structuré et plus fiable.

Remarque 78

Les systèmes multi-agents peuvent exhiber des comportements émergents : des propriétés du système global qui n’étaient pas explicitement programmées dans les agents individuels. Par exemple, un débat entre deux agents peut produire un raisonnement plus nuancé que celui de chaque agent pris isolément, ou un pipeline de relecture peut converger vers un consensus qui n’était dans la position initiale d’aucun agent. Ces propriétés émergentes sont à la fois la force et la difficulté des MAS — elles sont difficiles à prédire et à contrôler.

Remarque 79

Un système de \(n\) agents qui échangent \(k\) messages chacun génère un coût proportionnel à \(n \times k\) appels au LLM. Pour un débat en trois tours entre quatre agents, cela représente déjà 12 appels, soit un coût \(12\times\) supérieur à celui d’un agent unique. Ce multiplicateur de coût doit être soigneusement évalué : les gains en qualité justifient-ils le surcoût en latence, en tokens consommés et en budget ? En pratique, il faut trouver le point d’équilibre entre la qualité de la sortie et les ressources déployées.

Architectures multi-agents#

Il existe plusieurs façons d’organiser les intéractions entre agents. Chaque architecture correspond à un compromis entre complexité, latence et qualité.

Définition 73 (Architecture séquentielle (pipeline))

Dans une architecture séquentielle, les agents sont organisés en en chaine : la sortie de l’agent \(A_i\) devient l’entrée de l’agent \(A_{i+1}\). Formellement :

\[y_0 = x, \quad y_i = A_i(y_{i-1}), \quad y = y_n\]

où \(x\) est l’entrée initiale et \(y\) la sortie finale. Chaque agent raffine, corrige ou enrichit le travail de son prédécesseur. C’est l’architecture la plus simple à implémenter et à déboguer.

L’architecture parallèle distribue la tâche à plusieurs agents simultanément, puis fusionne leurs résultats. Elle est utile lorsque la tâche peut être décomposée en sous-tâches indépendantes ou lorsqu’on souhaite obtenir des perspectives diversifiées. L’architecture hiérarchique (superviseur-travailleurs) ajoute un niveau de contrôle : un agent superviseur décompose la tâche, la distribue aux travailleurs, collecte les résultats et les synthétise. L’architecture de débat met en opposition plusieurs agents qui argumentent pour ou contre une position, sous l’arbitrage d’un juge.

Hide code cell source

 
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import seaborn as sns
import networkx as nx
from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
import random
import time

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)
np.random.seed(42)
random.seed(42)

Hide code cell source

 
# Framework multi-agents minimal

@dataclass
class Message:
    """Un message échangé entre agents."""
    sender: str
    receiver: str
    content: str
    turn: int = 0

@dataclass
class Agent:
    """Un agent avec un rôle et une logique de réponse simulée."""
    name: str
    role: str
    responses: List[str] = field(default_factory=list)
    _response_idx: int = field(default=0, repr=False)

    def respond(self, input_text: str, turn: int = 0) -> str:
        """Simule une réponse du LLM selon le rôle de l'agent."""
        if self.responses:
            response = self.responses[self._response_idx % len(self.responses)]
            self._response_idx += 1
            return response
        return f"[{self.name}] Réponse par défaut à : {input_text[:50]}..."

class MessageBus:
    """Bus de messages pour la communication inter-agents."""
    def __init__(self):
        self.messages: List[Message] = []
        self.turn: int = 0

    def send(self, sender: str, receiver: str, content: str):
        msg = Message(sender=sender, receiver=receiver,
                      content=content, turn=self.turn)
        self.messages.append(msg)

    def get_messages_for(self, receiver: str) -> List[Message]:
        return [m for m in self.messages if m.receiver == receiver]

    def get_all_messages(self) -> List[Message]:
        return self.messages.copy()

    def next_turn(self):
        self.turn += 1

class Supervisor:
    """Superviseur qui décompose les tâches et coordonne les travailleurs."""
    def __init__(self, name: str, workers: List[Agent]):
        self.name = name
        self.workers = {w.name: w for w in workers}
        self.bus = MessageBus()

    def decompose(self, task: str) -> Dict[str, str]:
        """Décompose une tâche en sous-tâches pour chaque travailleur."""
        subtasks = {}
        for worker_name in self.workers:
            subtasks[worker_name] = f"[Sous-tâche pour {worker_name}] {task}"
        return subtasks

    def execute(self, task: str) -> Dict[str, str]:
        """Exécute la tâche en coordonnant les travailleurs."""
        subtasks = self.decompose(task)
        results = {}
        for worker_name, subtask in subtasks.items():
            self.bus.send(self.name, worker_name, subtask)
            worker = self.workers[worker_name]
            response = worker.respond(subtask)
            self.bus.send(worker_name, self.name, response)
            results[worker_name] = response
        return results

print("Framework multi-agents initialisé.")
print(f"Classes disponibles : Agent, MessageBus, Supervisor")

Framework multi-agents initialisé.
Classes disponibles : Agent, MessageBus, Supervisor

Définition 74 (Passage de messages)

Le passage de messages (message passing) est le mécanisme de communication fondamental dans les MAS. Chaque message \(m\) est un tuple \((s, r, c, t)\) ou :

  • \(s \in \mathcal{A}\) est l”expéditeur,

  • \(r \in \mathcal{A}\) est le destinataire,

  • \(c\) est le contenu (texte, données structurées),

  • \(t \in \mathbb{N}\) est le tour de communication.

Le bus de messages maintient un historique ordonné \(\mathcal{H} = (m_1, m_2, \ldots, m_T)\) qui constitue la trace du système, essentielle pour le débogage et l’évaluation.

Communication et protocoles#

La qualité d’un système multi-agents dépend autant de la qualité de ses agents individuels que de la qualité de leur communication. Un protocole de communication bien conçu réduit l’ambiguïté, évite les boucles infinies et garantit la convergence vers un résultat.

On distingue trois grands modes de communication. Le passage de messages direct (point-to-point) : chaque agent envoie des messages à des destinataires spécifiques. C’est le mode le plus flexible mais aussi le plus difficile à coordonner lorsque le nombre d’agents croit. Le tableau noir (blackboard) : tous les agents lisent et écrivent sur un espace partagé. C’est un mode naturel pour les tâches collaboratives où chaque agent enrichit progressivement un artefact commun. La communication structurée par rôles : le protocole impose des tours de parole et des formats de message en fonction du rôle de chaque agent.

Exemple 54 (Chaine de relecture multi-agents)

Un pipeline de relecture en trois étapes illustre l’architecture séquentielle :

Tâche initiale
    |
    v
[Rédacteur] --> brouillon
    |
    v
[Relecteur] --> critique + suggestions
    |
    v
[Editeur]   --> version finale

Chaque agent reçoit la sortie de l’agent précédent et l’améliore. Le rédacteur produit un premier jet, le relecteur identifie les erreurs et propose des corrections, l’éditeur intègre les corrections et produit la version finale.

Hide code cell source

 
# Simulation d'un pipeline de relecture (architecture sequentielle)

redacteur = Agent(
    name="Redacteur",
    role="Rédige un premier brouillon",
    responses=[
        "Les systèmes multi-agents permettent de diviser les tâches complexes "
        "entre plusieurs entités autonomes. Chaque agent se spécialise dans un "
        "aspect spécifique, ce qui améliore la qualité global du résultat."
    ]
)

relecteur = Agent(
    name="Relecteur",
    role="Identifie les erreurs et propose des améliorations",
    responses=[
        "CORRECTIONS :\n"
        "1. 'qualité global' -> 'qualité globale' (accord adjectif)\n"
        "2. Suggestion : ajouter un exemple concret pour illustrer\n"
        "3. Le texte est clair mais pourrait mentionner les défis (coût, coordination)"
    ]
)

editeur = Agent(
    name="Editeur",
    role="Produit la version finale en intégrant les corrections",
    responses=[
        "Les systèmes multi-agents permettent de diviser les tâches complexes "
        "entre plusieurs entités autonomes. Chaque agent se spécialise dans un "
        "aspect spécifique --- par exemple, un rédacteur, un relecteur et un "
        "éditeur --- ce qui améliore la qualité globale du résultat. Cette "
        "approche comporte néanmoins des defis : coût accru des appels au LLM "
        "et nécessité d'une coordination efficace entre agents."
    ]
)

# Exécution du pipeline
pipeline_agents = [redacteur, relecteur, editeur]
bus = MessageBus()
current_input = "Rédiger un paragraphe sur les systèmes multi-agents."

print("=" * 70)
print("PIPELINE DE RELECTURE SEQUENTIEL")
print("=" * 70)

for i, agent in enumerate(pipeline_agents):
    response = agent.respond(current_input)
    bus.send("pipeline" if i == 0 else pipeline_agents[i-1].name,
             agent.name, current_input)
    bus.send(agent.name, "pipeline", response)
    bus.next_turn()

    print(f"\n--- Tour {i+1} : {agent.name} ({agent.role}) ---")
    print(response)
    current_input = response

print("\n" + "=" * 70)
print(f"Messages échangés : {len(bus.get_all_messages())}")

======================================================================
PIPELINE DE RELECTURE SEQUENTIEL
======================================================================

--- Tour 1 : Redacteur (Rédige un premier brouillon) ---
Les systèmes multi-agents permettent de diviser les tâches complexes entre plusieurs entités autonomes. Chaque agent se spécialise dans un aspect spécifique, ce qui améliore la qualité global du résultat.

--- Tour 2 : Relecteur (Identifie les erreurs et propose des améliorations) ---
CORRECTIONS :
1. 'qualité global' -> 'qualité globale' (accord adjectif)
2. Suggestion : ajouter un exemple concret pour illustrer
3. Le texte est clair mais pourrait mentionner les défis (coût, coordination)

--- Tour 3 : Editeur (Produit la version finale en intégrant les corrections) ---
Les systèmes multi-agents permettent de diviser les tâches complexes entre plusieurs entités autonomes. Chaque agent se spécialise dans un aspect spécifique --- par exemple, un rédacteur, un relecteur et un éditeur --- ce qui améliore la qualité globale du résultat. Cette approche comporte néanmoins des defis : coût accru des appels au LLM et nécessité d'une coordination efficace entre agents.

======================================================================
Messages échangés : 6

Remarque 80

Les systèmes multi-agents sont sujets à plusieurs modes de défaillance spécifiques :

  • Boucle de politesse : les agents s’accordent trop facilement sans apporter de critique réelle, ce qui annule le bénéfice de la vérification croisée.

  • Cascade d’erreurs : dans un pipeline sequentiel, une erreur du premier agent peut être amplifiée par les agents suivants au lieu d’être corrigée.

  • Effondrement de la diversité : après plusieurs tours de débat, les agents convergent vers une position consensuelle qui n’est pas nécessairement la meilleure.

  • Explosion combinatoire : dans les architectures plate où chaque agent communique avec tous les autres, le nombre de messages croit en \(O(n^2)\) par tour.

Architecture de débat#

L’architecture de débat est l’une des plus prometteuses pour améliorer la qualité du raisonnement. Elle s’inspire des pratiques humaines de déliberation : lorsque deux personnes défendent des positions opposées devant un juge, le juge peut évaluer la qualité relative des arguments et parvenir è une conclusion plus éclairée.

Définition 75 (Architecture de débat)

Une architecture de débat est un tuple \((\mathcal{D}, J, T)\) où :

  • \(\mathcal{D} = \{D_1, \ldots, D_k\}\) est un ensemble de débatteurs, chacun défendant une position \(p_i\) sur la question posée,

  • \(J\) est un juge (ou modérateur) qui évalue les arguments et produit la synthèse finale,

  • \(T \in \mathbb{N}^*\) est le nombre de tours de débat.

A chaque tour \(t\), chaque débatteur \(D_i\) produit un argument \(a_i^{(t)}\) en fonction de sa position, des arguments adverses \(\{a_j^{(t-1)} : j \neq i\}\), et de l’historique. Apres \(T\) tours, le juge \(J\) synthétise l’ensemble des arguments et produit la conclusion \(y = J(a_1^{(1)}, \ldots, a_k^{(T)})\).

L’intérêt du débat réside dans le raisonnement adversarial : chaque débatteur est incité à trouver les faiblesses de l’argument adverse, ce qui force un examen plus rigoureux des hypothèses. Des travaux récents (Du et al., 2023 ; Liang et al., 2023) montrent que le débat entre LLM améliore significativement la précision sur des tâches de raisonnement mathématique et de vérification factuelle.

Hide code cell source

 
# Simulation de débat entre agents

class DebateAgent(Agent):
    """Agent de débat avec un score de confiance."""
    def __init__(self, name: str, role: str, position: str,
                 arguments: List[str], confidence: float = 0.7):
        super().__init__(name=name, role=role, responses=arguments)
        self.position = position
        self.confidence = confidence
        self.confidence_history = [confidence]

    def respond(self, input_text: str, turn: int = 0) -> str:
        response = super().respond(input_text, turn)
        # La confiance fluctue selon le tour
        delta = np.random.uniform(-0.1, 0.05)
        self.confidence = np.clip(self.confidence + delta, 0.1, 0.95)
        self.confidence_history.append(self.confidence)
        return response

# Question : "Les systèmes multi-agents sont-ils supérieurs aux agents uniques ?"
debater_pour = DebateAgent(
    name="Agent_Pour",
    role="Défend les systèmes multi-agents",
    position="pour",
    arguments=[
        "Les MAS offrent une vérification croisée : un agent relecteur détecte "
        "les erreurs que le redacteur ne voit pas. Des études montrent une "
        "réduction de 30% des hallucinations avec un pipeline de vérification.",

        "La spécialisation permet à chaque agent de se concentrer sur son "
        "domaine d'expertise. Un agent expert en code et un agent expert en "
        "mathématiques produisent ensemble un résultat supérieur à un généraliste.",

        "Le débat adversarial entre agents améliore la qualité du raisonnement. "
        "Les travaux de Du et al. (2023) montrent +15% de précision sur GSM8K "
        "avec un débat à trois agents par rapport à un agent unique."
    ],
    confidence=0.8
)

debater_contre = DebateAgent(
    name="Agent_Contre",
    role="Défend les agents uniques",
    position="contre",
    arguments=[
        "Le coût des MAS est prohibitif : un système de 4 agents avec 3 tours "
        "de débat consomme 12x plus de tokens qu'un agent unique. Pour une "
        "qualité marginalement supérieure, le ratio coût/bénéfice est défavorable.",

        "La coordination entre agents introduit de nouveaux modes de défaillance : "
        "boucles de politesse, cascades d'erreurs, effondrement de la diversité. "
        "Un agent unique bien prompté évite ces ecueils.",

        "Les gains observés dans la littérature sont souvent marginaux sur les "
        "tâches simples. Un seul agent avec chain-of-thought et self-consistency "
        "atteint des performances comparables à moindre coût."
    ],
    confidence=0.75
)

# Simulation du débat
question = "Les systèmes multi-agents sont-ils supérieurs aux agents uniques ?"
n_tours = 3
debate_trace = []

print("=" * 70)
print(f"DEBAT : {question}")
print("=" * 70)

for t in range(n_tours):
    print(f"\n{'─' * 70}")
    print(f"TOUR {t + 1}")
    print(f"{'─' * 70}")

    for debater in [debater_pour, debater_contre]:
        argument = debater.respond(question, turn=t)
        debate_trace.append({
            "tour": t + 1,
            "agent": debater.name,
            "position": debater.position,
            "argument": argument,
            "confiance": debater.confidence
        })
        print(f"\n[{debater.name}] (confiance: {debater.confidence:.2f})")
        print(f"  {argument}")

# Verdict du juge
print(f"\n{'=' * 70}")
print("VERDICT DU JUGE")
print(f"{'=' * 70}")
conf_pour = debater_pour.confidence
conf_contre = debater_contre.confidence
print(f"\nConfiance finale Agent_Pour  : {conf_pour:.2f}")
print(f"Confiance finale Agent_Contre: {conf_contre:.2f}")
print(f"\nSynthèse : Les systèmes multi-agents offrent des avantages réels "
      f"(vérification croisée, spécialisation) mais leur coût et leur "
      f"complexité doivent être soigneusement évalués. Ils sont particulièrement "
      f"adaptés aux tâches critiques ou la qualité prime sur le coût.")

======================================================================
DEBAT : Les systèmes multi-agents sont-ils supérieurs aux agents uniques ?
======================================================================

──────────────────────────────────────────────────────────────────────
TOUR 1
──────────────────────────────────────────────────────────────────────

[Agent_Pour] (confiance: 0.76)
  Les MAS offrent une vérification croisée : un agent relecteur détecte les erreurs que le redacteur ne voit pas. Des études montrent une réduction de 30% des hallucinations avec un pipeline de vérification.

[Agent_Contre] (confiance: 0.79)
  Le coût des MAS est prohibitif : un système de 4 agents avec 3 tours de débat consomme 12x plus de tokens qu'un agent unique. Pour une qualité marginalement supérieure, le ratio coût/bénéfice est défavorable.

──────────────────────────────────────────────────────────────────────
TOUR 2
──────────────────────────────────────────────────────────────────────

[Agent_Pour] (confiance: 0.77)
  La spécialisation permet à chaque agent de se concentrer sur son domaine d'expertise. Un agent expert en code et un agent expert en mathématiques produisent ensemble un résultat supérieur à un généraliste.

[Agent_Contre] (confiance: 0.78)
  La coordination entre agents introduit de nouveaux modes de défaillance : boucles de politesse, cascades d'erreurs, effondrement de la diversité. Un agent unique bien prompté évite ces ecueils.

──────────────────────────────────────────────────────────────────────
TOUR 3
──────────────────────────────────────────────────────────────────────

[Agent_Pour] (confiance: 0.69)
  Le débat adversarial entre agents améliore la qualité du raisonnement. Les travaux de Du et al. (2023) montrent +15% de précision sur GSM8K avec un débat à trois agents par rapport à un agent unique.

[Agent_Contre] (confiance: 0.71)
  Les gains observés dans la littérature sont souvent marginaux sur les tâches simples. Un seul agent avec chain-of-thought et self-consistency atteint des performances comparables à moindre coût.

======================================================================
VERDICT DU JUGE
======================================================================

Confiance finale Agent_Pour  : 0.69
Confiance finale Agent_Contre: 0.71

Synthèse : Les systèmes multi-agents offrent des avantages réels (vérification croisée, spécialisation) mais leur coût et leur complexité doivent être soigneusement évalués. Ils sont particulièrement adaptés aux tâches critiques ou la qualité prime sur le coût.

Exemple 55 (Simulation de débat)

Le débat simule ci-dessus illustre la dynamique fondamentale : chaque débatteur avance des arguments factuels (réduction des hallucinations, coût en tokens), et le juge synthétise les perspectives. En pratique, avec de vrais LLM, on observerait :

Tour 1 : Arguments initiaux (positions fermes)
Tour 2 : Réponses aux arguments adverses (nuancement)
Tour 3 : Concessions partielles et renforcement des points forts
Verdict : Synthèse équilibrée par le juge

Les scores de confiance décroissent souvent au fil du débat, reflétant la prise en compte des contre-arguments. Le juge tire parti de cette dynamique pour identifier les points de consensus et de désaccord.

Hide code cell source

 
# Visualisation de la trace du débat

fig, axes = plt.subplots(1, 2, figsize=(13, 5))

# Confiance au fil des tours
tours_pour = list(range(len(debater_pour.confidence_history)))
tours_contre = list(range(len(debater_contre.confidence_history)))

axes[0].plot(tours_pour, debater_pour.confidence_history, 'o-',
             color='steelblue', linewidth=2, markersize=8, label='Agent Pour')
axes[0].plot(tours_contre, debater_contre.confidence_history, 's-',
             color='coral', linewidth=2, markersize=8, label='Agent Contre')
axes[0].set_xlabel("Tour")
axes[0].set_ylabel("Score de confiance")
axes[0].set_title("Evolution de la confiance au fil du débat")
axes[0].set_ylim(0, 1)
axes[0].legend()
axes[0].set_xticks(range(max(len(tours_pour), len(tours_contre))))

# Arguments par tour (barres de confiance)
positions = []
confs = []
colors = []
labels_bar = []

for entry in debate_trace:
    positions.append(f"T{entry['tour']} {entry['agent'].split('_')[1]}")
    confs.append(entry['confiance'])
    colors.append('steelblue' if entry['position'] == 'pour' else 'coral')
    labels_bar.append(entry['agent'])

axes[1].barh(range(len(positions)), confs, color=colors, alpha=0.8,
             edgecolor='white', linewidth=0.5)
axes[1].set_yticks(range(len(positions)))
axes[1].set_yticklabels(positions, fontsize=9)
axes[1].set_xlabel("Score de confiance")
axes[1].set_title("Confiance par argument")
axes[1].set_xlim(0, 1)
axes[1].invert_yaxis()

pour_patch = mpatches.Patch(color='steelblue', label='Pour')
contre_patch = mpatches.Patch(color='coral', label='Contre')
axes[1].legend(handles=[pour_patch, contre_patch])

plt.show()
_images/239a536b49a109d77a475746c192048c2699bde45ed686fe688579ff4cbd8684.png

Architecture hiérarchique#

L’architecture hiérarchique place un superviseur au sommet de la chaine de commandement. Le superviseur reçoit la tâche globale, la décompose en sous-tâches, les distribue aux travailleurs, collecte les résultats et les synthétise. Cette architecture est particulièrement adaptée aux tâches qui admettent une décomposition naturelle en sous-problèmes indépendants.

Définition 76 (Architecture hierarchique)

Une architecture hiérarchique est un arbre \(\mathcal{T} = (V, E)\) où :

  • la racine \(v_0\) est le superviseur principal,

  • les noeuds internes \(v_i\) sont des superviseurs intermédiaires (optionnels),

  • les feuilles \(v_j\) sont les travailleurs qui exécutent les sous-tâches,

  • chaque arête \((v_i, v_j) \in E\) représente une relation de délégation.

Le superviseur \(v_0\) décompose la tâche \(\tau\) en sous-tÂches \(\{\tau_1, \ldots, \tau_k\}\), chaque sous-tâche est assignáe à un travailleur ou à un superviseur intermédiaire qui la décompose à son tour. Les résultats remontent l’arbre par agrégation successive.

L’architecture hiérarchique offre plusieurs avantages. Elle réduit la complexité de la coordination : le superviseur n’a besoin de communiquer qu’avec ses subalternes directs, et non avec tous les agents. Elle permet une récursion naturelle : un superviseur intermédiaire peut lui-même décomposer sa sous-tâche. Elle fournit un point de contrôle central qui peut vérifier la cohérence des résultats avant de les agréger.

Exemple 56 (Superviseur et travailleurs)

Un système hiérarchique pour l’analyse d’un document technique :

         [Superviseur]
        /      |       \
       v       v        v
[Analyste   [Analyste  [Analyste
 technique]  style]     factuel]
       \       |       /
        v      v      v
     [Superviseur : synthèse]
              |
              v
         Rapport final

Le superviseur décompose la tâche « analyser ce document » en trois axes : analyse technique, analyse stylistique, vérification factuelle. Chaque analyste travaille indépendamment, puis le superviseur synthétise les trois rapports en un rapport final cohérent.

Hide code cell source

 
# Simulation d'une architecture hiérarchique
# Definir les travailleurs spécialisés
analyste_technique = Agent(
    name="Analyste_Technique",
    role="Analyse les aspects techniques",
    responses=[
        "ANALYSE TECHNIQUE :\n"
        "- L'architecture proposée utilise 3 couches de Transformers\n"
        "- Complexité temporelle : O(n^2 d) par couche\n"
        "- Point d'attention : la mémoire GPU peut être insuffisante pour n > 4096\n"
        "- Recommandation : envisager Flash Attention pour réduire la complexité mémoire"
    ]
)

analyste_style = Agent(
    name="Analyste_Style",
    role="Analyse le style et la clarté",
    responses=[
        "ANALYSE STYLISTIQUE :\n"
        "- Le document est globalement clair et bien structuré\n"
        "- Section 3 : trop de jargon sans définitions préalables\n"
        "- Les figures manquent de légendes détaillées\n"
        "- Recommandation : ajouter un glossaire en annexe"
    ]
)

analyste_factuel = Agent(
    name="Analyste_Factuel",
    role="Vérifie l'exactitude des affirmations",
    responses=[
        "VERIFICATION FACTUELLE :\n"
        "- Affirmation 'BERT utilise 110M paramètres' : CORRECT\n"
        "- Affirmation 'GPT-4 est open-source' : INCORRECT (modèle propriétaire)\n"
        "- Référence [12] non trouvée dans la bibliographie\n"
        "- Recommandation : corriger l'affirmation sur GPT-4 et compléter les références"
    ]
)

# Créer le superviseur
supervisor = Supervisor(
    name="Superviseur",
    workers=[analyste_technique, analyste_style, analyste_factuel]
)

# Exécuter la tâche
task = "Analyser le document technique sur les architectures Transformer"
results = supervisor.execute(task)

print("=" * 70)
print("ARCHITECTURE HIERARCHIQUE : ANALYSE DE DOCUMENT")
print("=" * 70)
print(f"\nTache : {task}")
print(f"Nombre de travailleurs : {len(supervisor.workers)}")

for worker_name, result in results.items():
    print(f"\n{'─' * 70}")
    print(f"[{worker_name}]")
    print(result)

print(f"\n{'=' * 70}")
print("SYNTHESE DU SUPERVISEUR")
print(f"{'=' * 70}")
print("\nLe document présente des bases techniques solides (architecture")
print("Transformer correctement décrite) mais contient une erreur factuelle")
print("majeure (GPT-4 décrit comme open-source) et des lacunes stylistiques")
print("(jargon non défini, figures insuffisamment légendées). Priorité :")
print("corriger l'erreur factuelle avant publication.")
print(f"\nMessages échangés : {len(supervisor.bus.get_all_messages())}")

======================================================================
ARCHITECTURE HIERARCHIQUE : ANALYSE DE DOCUMENT
======================================================================

Tache : Analyser le document technique sur les architectures Transformer
Nombre de travailleurs : 3

──────────────────────────────────────────────────────────────────────
[Analyste_Technique]
ANALYSE TECHNIQUE :
- L'architecture proposée utilise 3 couches de Transformers
- Complexité temporelle : O(n^2 d) par couche
- Point d'attention : la mémoire GPU peut être insuffisante pour n > 4096
- Recommandation : envisager Flash Attention pour réduire la complexité mémoire

──────────────────────────────────────────────────────────────────────
[Analyste_Style]
ANALYSE STYLISTIQUE :
- Le document est globalement clair et bien structuré
- Section 3 : trop de jargon sans définitions préalables
- Les figures manquent de légendes détaillées
- Recommandation : ajouter un glossaire en annexe

──────────────────────────────────────────────────────────────────────
[Analyste_Factuel]
VERIFICATION FACTUELLE :
- Affirmation 'BERT utilise 110M paramètres' : CORRECT
- Affirmation 'GPT-4 est open-source' : INCORRECT (modèle propriétaire)
- Référence [12] non trouvée dans la bibliographie
- Recommandation : corriger l'affirmation sur GPT-4 et compléter les références

======================================================================
SYNTHESE DU SUPERVISEUR
======================================================================

Le document présente des bases techniques solides (architecture
Transformer correctement décrite) mais contient une erreur factuelle
majeure (GPT-4 décrit comme open-source) et des lacunes stylistiques
(jargon non défini, figures insuffisamment légendées). Priorité :
corriger l'erreur factuelle avant publication.

Messages échangés : 6

Propriété 18 (Passage à l’échelle des systèmes multi-agents)

La relation entre le nombre d’agents \(n\) et la qualité \(Q(n)\) de la sortie suit généralement une courbe à rendements décroissants :

\[Q(n) \approx Q_{\max} \left(1 - e^{-\alpha n}\right)\]

ou \(Q_{\max}\) est la qualite maximale atteignable et \(\alpha > 0\) contrôle la vitesse de convergence. En parallèle, le coût \(C(n)\) croit au moins linéairement :

\[C(n) \geq \beta \cdot n\]

Le point optimal \(n^*\) est celui qui maximise le rapport qualité-coût \(Q(n) / C(n)\). En pratique, les gains significatifs s’observent entre 2 et 5 agents ; au-delà, les rendements marginaux diminuent rapidement tandis que les coûts de coordination augmentent.

Hide code cell source

 
# Visualisation : performance vs nombre d'agents
n_agents = np.arange(1, 16)
alpha = 0.5
Q_max = 0.95
beta = 1.0

# Qualité (rendements décroissants)
quality = Q_max * (1 - np.exp(-alpha * n_agents))
# Coût (linéaire avec surcharge de coordination)
cost = beta * n_agents + 0.05 * n_agents ** 1.3
# Ratio qualité/coût
ratio = quality / cost

fig, axes = plt.subplots(1, 3, figsize=(15, 5))

axes[0].plot(n_agents, quality, 'o-', color='steelblue', linewidth=2, markersize=6)
axes[0].axhline(y=Q_max, color='gray', linestyle='--', alpha=0.5,
                label=f'$Q_{{\\max}} = {Q_max}$')
axes[0].fill_between(n_agents, quality, alpha=0.15, color='steelblue')
axes[0].set_xlabel("Nombre d'agents $n$")
axes[0].set_ylabel("Qualite $Q(n)$")
axes[0].set_title("Qualite vs nombre d'agents")
axes[0].legend()

axes[1].plot(n_agents, cost, 's-', color='coral', linewidth=2, markersize=6)
axes[1].fill_between(n_agents, cost, alpha=0.15, color='coral')
axes[1].set_xlabel("Nombre d'agents $n$")
axes[1].set_ylabel("Cout $C(n)$")
axes[1].set_title("Cout vs nombre d'agents")

optimal_idx = np.argmax(ratio)
axes[2].plot(n_agents, ratio, 'D-', color='seagreen', linewidth=2, markersize=6)
axes[2].axvline(x=n_agents[optimal_idx], color='coral', linestyle='--',
                alpha=0.7, label=f'$n^* = {n_agents[optimal_idx]}$')
axes[2].fill_between(n_agents, ratio, alpha=0.15, color='seagreen')
axes[2].set_xlabel("Nombre d'agents $n$")
axes[2].set_ylabel("Ratio $Q(n) / C(n)$")
axes[2].set_title("Ratio qualite/cout")
axes[2].legend()

plt.show()
_images/4349d7bce861d521a6faca927133c391629f323b97247cee1ae05f5e9380f0ee.png

Hide code cell source

 
# Visualisation : diagrammes des 3 architectures

fig, axes = plt.subplots(1, 3, figsize=(16, 6))

# --- Architecture séquentielle ---
ax = axes[0]
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.set_aspect('equal')
ax.set_title("Sequentielle (pipeline)", fontsize=13, fontweight='bold')
ax.axis('off')

seq_positions = [(5, 9), (5, 6.5), (5, 4), (5, 1.5)]
seq_labels = ["Entree", "Agent $A_1$", "Agent $A_2$", "Agent $A_3$"]
seq_colors = ['#E8E8E8', '#6BAED6', '#74C476', '#FD8D3C']

for (x, y), label, color in zip(seq_positions, seq_labels, seq_colors):
    rect = mpatches.FancyBboxPatch((x - 1.8, y - 0.6), 3.6, 1.2,
                                    boxstyle="round,pad=0.1",
                                    facecolor=color, edgecolor='black',
                                    linewidth=1.5)
    ax.add_patch(rect)
    ax.text(x, y, label, ha='center', va='center', fontsize=10,
            fontweight='bold')

for i in range(len(seq_positions) - 1):
    ax.annotate('', xy=(seq_positions[i+1][0], seq_positions[i+1][1] + 0.7),
                xytext=(seq_positions[i][0], seq_positions[i][1] - 0.7),
                arrowprops=dict(arrowstyle='->', color='black', lw=2))

# --- Architecture hiérarchique ---
ax = axes[1]
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.set_aspect('equal')
ax.set_title("Hiérarchique (superviseur)", fontsize=13, fontweight='bold')
ax.axis('off')

hier_positions = {
    'Superviseur': (5, 8.5),
    'Worker $W_1$': (1.8, 5),
    'Worker $W_2$': (5, 5),
    'Worker $W_3$': (8.2, 5),
    'Synthèse': (5, 1.5)
}
hier_colors = {
    'Superviseur': '#FD8D3C',
    'Worker $W_1$': '#6BAED6', 'Worker $W_2$': '#6BAED6',
    'Worker $W_3$': '#6BAED6',
    'Synthèse': '#74C476'
}

for label, (x, y) in hier_positions.items():
    w = 2.8 if label == 'Superviseur' or label == 'Synthese' else 2.4
    rect = mpatches.FancyBboxPatch((x - w/2, y - 0.6), w, 1.2,
                                    boxstyle="round,pad=0.1",
                                    facecolor=hier_colors[label],
                                    edgecolor='black', linewidth=1.5)
    ax.add_patch(rect)
    ax.text(x, y, label, ha='center', va='center', fontsize=9,
            fontweight='bold')

# Flèches superviseur -> workers
for wname in ['Worker $W_1$', 'Worker $W_2$', 'Worker $W_3$']:
    wx, wy = hier_positions[wname]
    ax.annotate('', xy=(wx, wy + 0.7),
                xytext=(5, 8.5 - 0.7),
                arrowprops=dict(arrowstyle='->', color='black', lw=1.5))

# Flèches workers -> synthèse
for wname in ['Worker $W_1$', 'Worker $W_2$', 'Worker $W_3$']:
    wx, wy = hier_positions[wname]
    ax.annotate('', xy=(5, 1.5 + 0.7),
                xytext=(wx, wy - 0.7),
                arrowprops=dict(arrowstyle='->', color='black', lw=1.5))

# --- Architecture de débat ---
ax = axes[2]
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
ax.set_aspect('equal')
ax.set_title("Débat (adversarial)", fontsize=13, fontweight='bold')
ax.axis('off')

debate_positions = {
    'Débatteur $D_1$': (2.5, 7.5),
    'Débatteur $D_2$': (7.5, 7.5),
    'Juge $J$': (5, 2)
}
debate_colors = {
    'Débatteur $D_1$': '#6BAED6',
    'Débatteur $D_2$': '#FC9272',
    'Juge $J$': '#74C476'
}

for label, (x, y) in debate_positions.items():
    w = 3.2
    rect = mpatches.FancyBboxPatch((x - w/2, y - 0.6), w, 1.2,
                                    boxstyle="round,pad=0.1",
                                    facecolor=debate_colors[label],
                                    edgecolor='black', linewidth=1.5)
    ax.add_patch(rect)
    ax.text(x, y, label, ha='center', va='center', fontsize=9,
            fontweight='bold')

# Flèches bidirectionnelles entre débatteurs
ax.annotate('', xy=(6, 7.8), xytext=(4, 7.8),
            arrowprops=dict(arrowstyle='<->', color='red', lw=2,
                            linestyle='--'))
ax.text(5, 8.3, "debat", ha='center', va='center', fontsize=9,
        fontstyle='italic', color='red')

# Flèches débatteurs -> juge
for dname in ['Débatteur $D_1$', 'Débatteur $D_2$']:
    dx, dy = debate_positions[dname]
    jx, jy = debate_positions['Juge $J$']
    ax.annotate('', xy=(jx, jy + 0.7),
                xytext=(dx, dy - 0.7),
                arrowprops=dict(arrowstyle='->', color='black', lw=1.5))

plt.show()
_images/9e5ade24bac3a4527d8ff0c9c12c9b6007b7a8a8a9dbf459f6929ea1799401ee.png

Coordination et consensus#

Lorsque plusieurs agents travaillent sur une même tâche, il faut un mécanisme pour agréger leurs sorties et résoudre les désaccords. Les mécanismes de consensus sont au coeur de la qualité des systèmes multi-agents.

Le vote majoritaire est le mécanisme le plus simple : chaque agent produit une réponse, et la réponse la plus fréquente est sélectionnée. Ce mécanisme est efficace lorsque les agents sont indépendants et ont chacun une probabilité supérieure à \(1/2\) d’être corrects (théorème du jury de Condorcet). Le consensus pondéré attribue un poids à chaque agent en fonction de sa fiabilité estimée ou de sa spécialisation. La résolution de conflits intervient lorsque les agents produisent des réponses contradictoires : un agent arbitre examine les arguments et tranche.

Hide code cell source

 
# Simulation de mécanismes de consensus

def vote_majoritaire(reponses: List[str]) -> Tuple[str, float]:
    """Vote majoritaire simple."""
    from collections import Counter
    compteur = Counter(reponses)
    gagnant, count = compteur.most_common(1)[0]
    return gagnant, count / len(reponses)

def consensus_pondere(reponses: List[str], poids: List[float]) -> Tuple[str, float]:
    """Consensus pondéré par la fiabilité des agents."""
    scores = {}
    total_poids = sum(poids)
    for rep, w in zip(reponses, poids):
        scores[rep] = scores.get(rep, 0) + w
    gagnant = max(scores, key=scores.get)
    return gagnant, scores[gagnant] / total_poids

# Simulation : 7 agents répondent à une question factuelle
# Reponse correcte : "Paris"
np.random.seed(42)
n_simulations = 1000
n_agents_list = [3, 5, 7, 9, 11]
p_correct = 0.65  # Probabilite individuelle d'être correct

resultats_vote = {n: 0 for n in n_agents_list}
resultats_pondere = {n: 0 for n in n_agents_list}

for n_ag in n_agents_list:
    for _ in range(n_simulations):
        # Chaque agent est correct avec probabilité p_correct
        reponses = ["Paris" if np.random.random() < p_correct
                     else "Lyon" for _ in range(n_ag)]
        poids = np.random.dirichlet(np.ones(n_ag) * 2)

        gagnant_vote, _ = vote_majoritaire(reponses)
        gagnant_pond, _ = consensus_pondere(reponses, poids.tolist())

        if gagnant_vote == "Paris":
            resultats_vote[n_ag] += 1
        if gagnant_pond == "Paris":
            resultats_pondere[n_ag] += 1

# Affichage
print(f"Probabilité individuelle d'être correct : {p_correct:.0%}")
print(f"\n{'Nb agents':<12} {'Vote majoritaire':>18} {'Consensus pondéré':>20}")
print("-" * 52)
for n_ag in n_agents_list:
    acc_vote = resultats_vote[n_ag] / n_simulations
    acc_pond = resultats_pondere[n_ag] / n_simulations
    print(f"{n_ag:<12} {acc_vote:>18.1%} {acc_pond:>20.1%}")

Probabilité individuelle d'être correct : 65%

Nb agents      Vote majoritaire    Consensus pondéré
----------------------------------------------------
3                         74.2%                71.7%
5                         75.7%                72.0%
7                         81.2%                75.4%
9                         83.7%                80.1%
11                        84.3%                80.0%

Le théorème du jury de Condorcet formalise l’intuition que le vote majoritaire améliore la précision lorsque chaque votant est individuellement meilleur que le hasard. Si chaque agent a une probabilité \(p > 0{,}5\) d’être correct et que les agents sont indépendants, alors la probabilité que la majorité soit correcte tend vers 1 lorsque le nombre d’agents tend vers l’infini. En revanche, si \(p < 0{,}5\), ajouter des agents détériore le résultat.

Hide code cell source

 
# Visualisation : graphe de communication (networkx)

fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# --- Graphe séquentiel ---
G_seq = nx.DiGraph()
seq_nodes = ["Entrée", "A1\nRédacteur", "A2\nRelecteur", "A3\nEditeur", "Sortie"]
G_seq.add_nodes_from(seq_nodes)
for i in range(len(seq_nodes) - 1):
    G_seq.add_edge(seq_nodes[i], seq_nodes[i+1], weight=1)

pos_seq = {node: (i * 2, 0) for i, node in enumerate(seq_nodes)}
node_colors_seq = ['#E8E8E8', '#6BAED6', '#74C476', '#FD8D3C', '#E8E8E8']

nx.draw(G_seq, pos_seq, ax=axes[0], with_labels=True, node_color=node_colors_seq,
        node_size=2000, font_size=8, font_weight='bold',
        edge_color='gray', width=2, arrows=True, arrowsize=20,
        connectionstyle='arc3,rad=0.0')
axes[0].set_title("Pipeline séquentiel", fontsize=12, fontweight='bold')

# --- Graphe hiérarchique ---
G_hier = nx.DiGraph()
hier_nodes = ["Superviseur", "W1\nTechnique", "W2\nStyle", "W3\nFactuel"]
G_hier.add_nodes_from(hier_nodes)
for w in hier_nodes[1:]:
    G_hier.add_edge("Superviseur", w)
    G_hier.add_edge(w, "Superviseur")

pos_hier = {
    "Superviseur": (2, 2),
    "W1\nTechnique": (0, 0),
    "W2\nStyle": (2, 0),
    "W3\nFactuel": (4, 0)
}
node_colors_hier = ['#FD8D3C', '#6BAED6', '#6BAED6', '#6BAED6']

nx.draw(G_hier, pos_hier, ax=axes[1], with_labels=True,
        node_color=node_colors_hier, node_size=2000, font_size=8,
        font_weight='bold', edge_color='gray', width=1.5,
        arrows=True, arrowsize=15, connectionstyle='arc3,rad=0.1')
axes[1].set_title("Hierarchique", fontsize=12, fontweight='bold')

# --- Graphe de débat (complet) ---
G_debate = nx.DiGraph()
debate_nodes = ["D1\nPour", "D2\nContre", "Juge"]
G_debate.add_nodes_from(debate_nodes)
# Débatteurs communiquent entre eux et avec le juge
G_debate.add_edge("D1\nPour", "D2\nContre")
G_debate.add_edge("D2\nContre", "D1\nPour")
G_debate.add_edge("D1\nPour", "Juge")
G_debate.add_edge("D2\nContre", "Juge")

pos_debate = {
    "D1\nPour": (0, 0),
    "D2\nContre": (4, 0),
    "Juge": (2, -2)
}
node_colors_debate = ['#6BAED6', '#FC9272', '#74C476']

nx.draw(G_debate, pos_debate, ax=axes[2], with_labels=True,
        node_color=node_colors_debate, node_size=2500, font_size=8,
        font_weight='bold', edge_color='gray', width=2,
        arrows=True, arrowsize=20, connectionstyle='arc3,rad=0.15')
axes[2].set_title("Débat adversarial", fontsize=12, fontweight='bold')

plt.show()
_images/6ed9cfa3cac89a98ac81f9bd1816a98ffa21e8706167815931f22eb52b864f0c.png

Hide code cell source

 
# Visualisation : performance du vote majoritaire vs nombre d'agents

fig, axes = plt.subplots(1, 2, figsize=(13, 5))

# Courbe théorique du théorème de Condorcet
n_range = np.arange(1, 52, 2)  # Nombres impairs
p_values = [0.55, 0.65, 0.75, 0.85]
colors_p = ['#FD8D3C', '#6BAED6', '#74C476', '#756BB1']

for p, color in zip(p_values, colors_p):
    # Probabilité que la majorité soit correcte
    from scipy.stats import binom
    prob_majority = [1 - binom.cdf(n // 2, n, p) for n in n_range]
    axes[0].plot(n_range, prob_majority, '-', color=color, linewidth=2,
                 label=f'$p = {p}$')

axes[0].axhline(y=1.0, color='gray', linestyle='--', alpha=0.3)
axes[0].set_xlabel("Nombre d'agents $n$")
axes[0].set_ylabel("$P$(majorité correcte)")
axes[0].set_title("Théorème du jury de Condorcet")
axes[0].legend(title="$p$ individuelle")
axes[0].set_ylim(0.4, 1.02)

# Résultats de la simulation
acc_vote = [resultats_vote[n] / n_simulations for n in n_agents_list]
acc_pond = [resultats_pondere[n] / n_simulations for n in n_agents_list]

x_pos = np.arange(len(n_agents_list))
width = 0.35

bars1 = axes[1].bar(x_pos - width/2, acc_vote, width, color='steelblue',
                     alpha=0.8, label='Vote majoritaire', edgecolor='white')
bars2 = axes[1].bar(x_pos + width/2, acc_pond, width, color='coral',
                     alpha=0.8, label='Consensus pondere', edgecolor='white')

axes[1].axhline(y=p_correct, color='gray', linestyle='--', alpha=0.5,
                label=f'$p$ individuelle = {p_correct}')
axes[1].set_xlabel("Nombre d'agents")
axes[1].set_ylabel("Précision du consensus")
axes[1].set_title("Simulation : vote vs consensus pondéré")
axes[1].set_xticks(x_pos)
axes[1].set_xticklabels(n_agents_list)
axes[1].legend()
axes[1].set_ylim(0.5, 1.02)

plt.show()
_images/5c2c656bf8fd5472875616ef0c92571eef9714c38d80a2587aafde894a7c2a70.png

La figure de gauche illustre le théorème de Condorcet : même avec des agents individuellement modestes (\(p = 0{,}55\)), le vote majoritaire dépasse 90 % de précision avec suffisamment d’agents. La figure de droite confirme ce résultat par simulation et compare le vote majoritaire au consensus pondéré. En pratique, le consensus pondéré n’apporte un avantage significatif que lorsque les poids reflètent fidèlement la compétence des agents, ce qui suppose un mécanisme d’estimation fiable.

Hide code cell source

 
# Visualisation : graphe de flux de messages dans un système complexe

G = nx.DiGraph()

# Noeuds : agents dans un système multi-agents complet
agents = {
    "Superviseur": {"type": "supervisor", "color": "#FD8D3C"},
    "Planificateur": {"type": "planner", "color": "#FDAE6B"},
    "Rédacteur": {"type": "worker", "color": "#6BAED6"},
    "Relecteur": {"type": "worker", "color": "#74C476"},
    "Vérificateur": {"type": "worker", "color": "#FC9272"},
    "Editeur": {"type": "worker", "color": "#9E9AC8"},
}

for name, attrs in agents.items():
    G.add_node(name, **attrs)

# Arêtes avec poids (nombre de messages)
edges = [
    ("Superviseur", "Planificateur", 3),
    ("Planificateur", "Rédacteur", 2),
    ("Planificateur", "Vérificateur", 2),
    ("Rédacteur", "Relecteur", 4),
    ("Relecteur", "Rédacteur", 3),
    ("Relecteur", "Editeur", 2),
    ("Vérificateur", "Relecteur", 2),
    ("Editeur", "Superviseur", 1),
    ("Rédacteur", "Superviseur", 1),
]

for src, dst, w in edges:
    G.add_edge(src, dst, weight=w)

pos = nx.spring_layout(G, seed=42, k=2)
node_colors = [agents[n]["color"] for n in G.nodes()]
edge_weights = [G[u][v]["weight"] for u, v in G.edges()]

fig, ax = plt.subplots(1, 1, figsize=(9, 6))

nx.draw_networkx_nodes(G, pos, ax=ax, node_color=node_colors,
                       node_size=2500, edgecolors='black', linewidths=1.5)
nx.draw_networkx_labels(G, pos, ax=ax, font_size=9, font_weight='bold')
nx.draw_networkx_edges(G, pos, ax=ax, edge_color='gray',
                       width=[w * 0.8 for w in edge_weights],
                       arrows=True, arrowsize=20,
                       connectionstyle='arc3,rad=0.1',
                       alpha=0.7)

# Etiquettes des aretes (nombre de messages)
edge_labels = {(u, v): f"{d['weight']} msg" for u, v, d in G.edges(data=True)}
nx.draw_networkx_edge_labels(G, pos, edge_labels, ax=ax, font_size=8,
                             font_color='dimgray')

ax.set_title("Flux de messages dans un système multi-agents",
             fontsize=13, fontweight='bold')
ax.axis('off')

# Legende
legend_elements = [
    mpatches.Patch(facecolor='#FD8D3C', edgecolor='black', label='Superviseur'),
    mpatches.Patch(facecolor='#FDAE6B', edgecolor='black', label='Planificateur'),
    mpatches.Patch(facecolor='#6BAED6', edgecolor='black', label='Rédacteur'),
    mpatches.Patch(facecolor='#74C476', edgecolor='black', label='Relecteur'),
    mpatches.Patch(facecolor='#FC9272', edgecolor='black', label='Vérificateur'),
    mpatches.Patch(facecolor='#9E9AC8', edgecolor='black', label='Editeur'),
]
ax.legend(handles=legend_elements, loc='lower left', fontsize=9,
          title="Agents", title_fontsize=10)

plt.show()
_images/c125dc68cd8a7cb4ef0c83f53340055767b9be0a290d64ec898c8b72e1e2fff9.png

Ce graphe de communication révèle la structure réelle des échanges dans un système multi-agents complexe. L’épaisseur des arêtes reflète le volume de messages : la boucle rédacteur-relecteur est la plus active, ce qui est attendu dans un processus itératif de révision. Le superviseur reçoit les sorties finales mais délègue la planification à un agent dedié, illustrant le principe de séparation des responsabilités.

Résumé#

Ce chapitre a présenté les fondements des systèmes multi-agents appliqués aux LLM :

  1. Motivation : les tâches complexes bénéficient de la division du travail, de la spécialisation et de la vérification croisée entre agents autonomes.

  2. Architectures : l’architecture séquentielle (pipeline) est la plus simple, l’architecture hiérarchique offre un contrôle centralisé, et l’architecture de débat améliore le raisonnement par confrontation adversariale.

  3. Communication : le passage de messages, le tableau noir et la communication structurée par rôles constituent les trois grands modes d’interaction. Le format des messages et le protocole d’échange déterminent l’efficacité du système.

  4. Débat : la confrontation argumentée entre agents, arbitrée par un juge, améliore la qualité du raisonnement sur les tâches de vérification factuelle et de raisonnement mathématique.

  5. Hiérarchie : la décomposition superviseur-travailleurs permet de structurer les tâches complexes, avec un point de contrôle central pour la cohérence.

  6. Consensus : le vote majoritaire et le consensus pondéré exploitent la sagesse collective des agents, avec des garanties théoriques (théorème de Condorcet) lorsque les agents sont individuellement fiables.

  7. Passage à l’échelle : les rendements de l’ajout d’agents sont décroissants ; le point optimal se situe généralement entre 2 et 5 agents, au-delà duquel les coûts de coordination l’emportent sur les gains en qualité.

Contenu