Multi-Agent Systems

Hierarchical (Supervisor / Manager)

A supervisor agent receives the user request, decomposes it into subtasks, and delegates to specialized worker agents. The supervisor collects results, synthesizes them, and may re-delegate if quality is insufficient.

         ┌─────────────┐
         │  Supervisor  │
         └──────┬───────┘
        ┌───────┼───────┐
        ▼       ▼       ▼
   ┌────────┐ ┌────────┐ ┌────────┐
   │Research│ │ Coder  │ │Reviewer│
   └────────┘ └────────┘ └────────┘

Pipeline / Sequential

Agents arranged in a fixed linear chain. Each agent transforms or enriches the output before passing it downstream. Simple, predictable, and easy to test each stage independently.

  ┌──────┐    ┌─────────┐    ┌──────────┐    ┌──────┐
  │Search│ ──▶│ Extract │ ──▶│Summarize │ ──▶│ Edit │
  └──────┘    └─────────┘    └──────────┘    └──────┘

Peer-to-Peer / Collaborative

Agents communicate directly with each other without a central coordinator. Each agent decides when to pass work to another agent based on its own assessment. More flexible but harder to debug; risk of infinite loops or circular delegation.

Debate / Adversarial

Two or more agents argue opposing positions or critique each other's outputs. A judge agent (or the user) decides the final answer. Reduces hallucination and surfaces edge cases, but is expensive since it requires multiple full reasoning passes.

Swarm

Inspired by biological swarms. Large numbers of lightweight agents each follow simple rules; complex behavior emerges from interactions. Agents are defined minimally with instructions and tools, and handoffs are simply tool calls that return another agent.

Message Passing

Agents exchange natural-language messages or structured JSON through a shared message bus. Used by AutoGen's GroupChat and LangGraph's state channels. Simple and human-readable, but token-expensive at scale.

Shared Memory / State

Agents read and write to a common state object (TypedDict, Pydantic model, Redis, or vector store). Efficient for structured data and avoids repeating information, but requires careful schema design and handling of race conditions in parallel execution.

Tool-Based Coordination

Agents coordinate by calling shared tools — e.g., a delegate_to_researcher tool that invokes another agent. Both OpenAI Swarm and Claude Agent SDK use this pattern: a handoff is literally a function call.

A2A Protocol (Google)

An open protocol for agent interoperability across frameworks and vendors. Uses Agent Cards (JSON metadata describing capabilities), structured Tasks as work units, and supports streaming via SSE and push notifications.

LangGraph — Supervisor Pattern

from langgraph.graph import StateGraph, MessagesState
from langgraph.prebuilt import create_react_agent

# Define specialized worker agents
research_agent = create_react_agent(model, tools=[search, wiki])
code_agent = create_react_agent(model, tools=[python_repl, file_write])

def supervisor(state: MessagesState):
    """Route to the right specialist based on the task."""
    response = model.invoke([
        SystemMessage("You are a supervisor. Route tasks to: researcher or coder."),
        *state["messages"]
    ])
    return {"next": response.content}

# Build the multi-agent graph
graph = StateGraph(MessagesState)
graph.add_node("supervisor", supervisor)
graph.add_node("researcher", research_agent)
graph.add_node("coder", code_agent)
graph.add_conditional_edges("supervisor", route_fn)
graph.set_entry_point("supervisor")
app = graph.compile()

CrewAI — Role-Based Team

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Researcher",
    goal="Find accurate and up-to-date information",
    tools=[search_tool, scrape_tool]
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    tools=[file_tool]
)

research_task = Task(description="Research multi-agent systems trends", agent=researcher)
write_task = Task(description="Write a report from findings", agent=writer)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential  # or Process.hierarchical
)
result = crew.kickoff()

OpenAI Swarm — Handoff Pattern

from swarm import Swarm, Agent

client = Swarm()

def transfer_to_sales():
    """Hand off to the sales agent."""
    return sales_agent

triage_agent = Agent(
    name="Triage",
    instructions="Route customer to the right department.",
    functions=[transfer_to_sales, transfer_to_support]
)

sales_agent = Agent(
    name="Sales",
    instructions="Help customers with purchases and pricing."
)

response = client.run(agent=triage_agent, messages=[{"role": "user", "content": "I want to buy"}])