Multi-Agent Topologies & Communication

When to Use Multiple Agents

The exam's most common trap: candidates choose multi-agent when single-agent is sufficient. Multi-agent adds complexity. You need to justify that complexity.

Decision Framework

USE SINGLE AGENT when:
  ✓ Task is sequential (step 1 → step 2 → step 3)
  ✓ One domain of expertise needed
  ✓ Shared context is critical (all steps need same information)
  ✓ Simple error recovery (retry the failed step)

USE MULTI-AGENT when:
  ✓ Tasks are parallelizable (independent work items)
  ✓ Different domains of expertise needed (legal + technical + creative)
  ✓ Adversarial review required (one agent checks another's work)
  ✓ Scale demands it (100 items to process simultaneously)
  ✓ Isolation required (one agent's failure shouldn't crash others)

Four Multi-Agent Topologies

1. Supervisor Pattern

         ┌──────────┐
         │SUPERVISOR│ ← orchestrates, delegates, reviews
         └────┬─────┘
        ┌─────┼─────┐
        ▼     ▼     ▼
    ┌──────┐┌──────┐┌──────┐
    │Worker││Worker││Worker│ ← specialized agents
    │  A   ││  B   ││  C   │
    └──────┘└──────┘└──────┘

USE WHEN: Clear hierarchy. Workers have different specializations.
          Supervisor maintains global context and quality.

EXAM EXAMPLE: Code review system
  - Supervisor: assigns files to reviewers, aggregates feedback
  - Worker A: security review
  - Worker B: performance review
  - Worker C: style/consistency review

2. Pipeline Pattern

┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐
│Agent │───▶│Agent │───▶│Agent │───▶│Agent │
│  1   │    │  2   │    │  3   │    │  4   │
└──────┘    └──────┘    └──────┘    └──────┘
Research → Draft → Review → Publish

USE WHEN: Sequential processing where each stage transforms output.
          Each agent adds value to the previous agent's output.

EXAM EXAMPLE: Content pipeline
  - Agent 1: Research topic (web search, data gathering)
  - Agent 2: Write draft (content generation)
  - Agent 3: Review and edit (quality check)
  - Agent 4: Format and publish (deployment)

3. Debate Pattern

┌──────┐         ┌──────┐
│Agent │◀───────▶│Agent │
│  A   │ debate  │  B   │
└──┬───┘         └──┬───┘
   │                 │
   └────────┬────────┘
            ▼
      ┌──────────┐
      │  JUDGE   │ ← picks best argument
      └──────────┘

USE WHEN: High-stakes decisions where you want adversarial thinking.
          Reduces bias by forcing opposing viewpoints.

EXAM EXAMPLE: Investment analysis
  - Agent A: argues FOR the investment (bull case)
  - Agent B: argues AGAINST (bear case)
  - Judge: weighs both arguments, makes decision

4. Swarm Pattern

┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐
│Agent │ │Agent │ │Agent │ │Agent │
│  1   │ │  2   │ │  3   │ │  N   │
└──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘
   │        │        │        │
   └────────┴────────┴────────┘
                 │
           ┌─────────┐
           │ SHARED  │ ← shared state/message bus
           │  STATE  │
           └─────────┘

USE WHEN: Many identical tasks, homogeneous agents, scale-out.
          Each agent works independently on its portion.

EXAM EXAMPLE: Processing 1000 support tickets
  - N identical agents each handle a subset
  - Shared state tracks which tickets are claimed
  - No coordination needed beyond "claim" mechanism

Inter-Agent Communication

How agents talk to each other matters. The exam tests three communication patterns:

Direct Message Passing

# Agent A sends result directly to Agent B
result_a = await agent_a.run(task)
result_b = await agent_b.run(result_a.output)  # pipeline

Pros: Simple, clear data flow. Cons: Tight coupling.

Shared Memory (Blackboard)

# Agents read/write to shared state
brain.write("research_findings", agent_research.output)
# Later...
findings = brain.read("research_findings")
draft = await agent_writer.run(findings)

Pros: Loose coupling, agents don't know about each other. Cons: Coordination complexity.

Event Bus

# Agents publish/subscribe to events
@on_event("research_complete")
async def handle_research(event):
    await agent_writer.run(event.data)

Pros: Fully decoupled, scalable. Cons: Harder to debug, eventual consistency.

Exam Scenario Practice

Key Takeaways

1. Don't over-architect. Single agent with tools beats multi-agent for most problems.
2. Match topology to problem. Supervisor for hierarchy, pipeline for stages, debate for decisions, swarm for scale.
3. Communication pattern matters. Shared memory (brain) for persistence. Direct passing for pipelines. Events for loose coupling.
4. The exam tests judgment. "Why this pattern?" is more important than "what does this pattern do?"