Multi-Agent Systems: AI Teams That Collaborate

L4-04 covered single Agents. This piece: what happens when one Agent isn’t enough.

Many real tasks benefit from multiple specialized Agents working together — like a software team where the engineer, reviewer, and QA each have different roles.

When You Need Multi-Agent

Single Agent works fine for:

• Q&A
• Tool-using assistant
• Simple workflows

Multi-Agent earns its complexity when:

• Task requires distinct expertise (research + code + review)
• You want self-checking (writer + critic loop)
• Parallel work (multiple sub-tasks, different specialists)
• Long-running projects (planning + execution + monitoring)

If you’re tempted to use Multi-Agent but a single Agent would do — single is simpler. Start there.

Common Patterns

1. Pipeline / Sequential

Agents pass work down a chain:

[Researcher] → [Outliner] → [Writer] → [Editor] → done

Each Agent does one stage. Simple, predictable, debuggable.

2. Hierarchical / Manager

A “manager” Agent decides what sub-Agents to call:

       [Manager]
       /    |    \
[Researcher] [Coder] [Designer]

Manager has a big picture; specialists do focused work.

3. Debate / Consensus

Multiple Agents argue, converge on answer:

Agent A: "I think it's X because..."
Agent B: "But that's wrong because... I say Y."
Agent C: "Let me synthesize: Z fits both views."

Used for: hard reasoning problems, ethical decisions. Cost: 3-5× single Agent.

4. Critic / Reviewer

One generates, another critiques:

[Writer] writes draft
   ↓
[Critic] reviews
   ↓
[Writer] revises
   ↓ (loop until critic approves)

Catches errors that the writer alone might miss.

5. Specialist Pool

Agents picked by task type:

Task: "Build a website with Stripe payments"
→ Picks: [Designer], [Backend], [Stripe expert], [Tester]

Frameworks

AutoGen (Microsoft, 2023)

from autogen import AssistantAgent, UserProxyAgent

planner = AssistantAgent(name="planner", system_message="Plan the work")
coder = AssistantAgent(name="coder", system_message="Write the code")
tester = AssistantAgent(name="tester", system_message="Test the code")

user = UserProxyAgent(name="user")

# Conversation loop
user.initiate_chat(
    planner,
    message="Build a calculator app"
)

Strength: most flexible, group chat support. Weakness: complex to debug.

CrewAI

Role-based, simpler API:

from crewai import Agent, Task, Crew

researcher = Agent(role="Senior Researcher", goal="Find relevant papers")
writer = Agent(role="Tech Writer", goal="Write a summary")

t1 = Task(description="Research X", agent=researcher)
t2 = Task(description="Write report on X", agent=writer)

crew = Crew(agents=[researcher, writer], tasks=[t1, t2])
crew.kickoff()

Strength: easy to start, clear roles. Weakness: less flexible than AutoGen.

LangGraph

Stateful workflow graphs:

from langgraph.graph import StateGraph

graph = StateGraph(MyState)
graph.add_node("researcher", researcher_agent)
graph.add_node("writer", writer_agent)
graph.add_node("critic", critic_agent)

graph.add_edge("researcher", "writer")
graph.add_conditional_edge("writer", "critic", lambda s: s.needs_review)
graph.add_edge("critic", "writer")  # Loop back if not approved

Strength: explicit control flow, great for complex flows. Weakness: more code than CrewAI.

Coordination Challenges

1. Communication overhead

Each Agent-to-Agent message = LLM round trip = $$$. 10 agents talking = 100 messages = costs explode.

Mitigation: rigid protocols, structured outputs (JSON not prose), summary compression.

2. Cascade failures

If Researcher gives wrong info, Writer + Editor build on a wrong foundation.

Mitigation: verification stages, citation requirements, Critic that questions sources.

3. Diverging agendas

Agents can drift from the task:

User: "Build a hello world script"
After 50 messages: agents debating optimal Python style guide

Mitigation: explicit task tracking, manager that re-grounds the conversation.

4. Cost / time blowup

Multi-Agent is 3-10× single Agent. Set hard limits.

A Real Pipeline

A content-creation multi-agent system:

Step 1: [Briefer]      ← takes user request, expands to spec
Step 2: [Researcher]   ← finds 10 source materials
Step 3: [Outliner]     ← creates structure
Step 4: [Writer]       ← drafts content
Step 5: [Fact-Checker] ← verifies claims, finds issues
Step 6: [Writer]       ← revises based on fact-check
Step 7: [Editor]       ← polishes tone, length
Step 8: [User]         ← reviews final

8 LLM calls + tool calls + DB queries. Cost: $0.5-2 per article. Time: 5-15 min.

For Anthropic / OpenAI’s “Deep Research” products — similar architecture under the hood.

When NOT to Use Multi-Agent

• Simple tasks — overhead not worth it
• Latency-critical — multi-agent is slow
• Cost-sensitive — N agents = N× cost
• Hard real-time — Agent loops are unpredictable

Many “we need multi-agent” requests really need a better single Agent. Try single first.

Future Directions

• Heterogeneous models: cheap model for simple Agents, premium for complex
• Persistent memory across Agents: shared knowledge base
• Asynchronous coordination: Agents work in parallel + sync points
• Self-organizing: Agents decide their own roles for the task

Next recommended: L4-11 Building MCP Tools or L4-12 LLM Cost Optimization.