Phase 5: AI Agents in Workflows · 55 min · LangChain · LangGraph · Dify

Multi-Agent Systems — Coordination, Delegation, and Specialization

Specialized agents, coordinated orchestration.

Hiring signal: Multi-agent systems are the frontier of production AI automation. Being able to explain when to use a single agent vs multiple specialized agents, and how to coordinate them (sequential, parallel, hierarchical), demonstrates advanced agent architecture experience that senior AI engineering roles require.

What you will learn

Understand multi-agent patterns: sequential, parallel, hierarchical (supervisor-worker)
Design specialized agents: each agent handles one domain (classification, extraction, validation)
Implement agent coordination: how agents pass results to each other
Decide when to use multi-agent vs single agent — complexity, specialization, and cost trade-offs

The Problem

A single AI agent tries to handle everything: classify emails, extract shipment data, validate carrier information, create orders, and send confirmations. It has 8 tools and a complex system prompt. It gets confused — calling the wrong tools, hallucinating carrier data, and taking 6+ iterations per email. The problem isn't the model; it's that one agent doing everything is cognitively overloaded.

The solution is specialization: a classification agent that only classifies, an extraction agent that only extracts fields, a validation agent that only checks data, and an orchestration agent that coordinates them. Each agent has a focused prompt, 1–2 tools, and does one thing well. This is the multi-agent pattern.

Multi-agent is about specialization, not complexity
A single agent with 8 tools is like a person doing 8 jobs poorly. Multi-agent systems give each agent one job and one or two tools. The coordination overhead is real (more API calls, more latency), but the quality improvement is significant — each agent excels at its specialty.

The Concept

Multi-Agent Coordination Patterns

┌──────────────────────────────────────────────────────────────┐
│  PATTERN 1: SEQUENTIAL (Pipeline)                             │
│                                                              │
│  [Classifier Agent] → [Extraction Agent] → [Validation Agent]│
│  → [Action Agent]                                            │
│  Each agent's output feeds the next. Simple, predictable.   │
│                                                              │
│  PATTERN 2: PARALLEL (Fan-out/Fan-in)                        │
│                                                              │
│  [Orchestrator] ─┬→ [Classification Agent] ─┐               │
│                  ├→ [Entity Extraction Agent] ├→ [Merger]   │
│                  └→ [Sentiment Agent] ────────┘               │
│  Agents run simultaneously, results merged. Fast.           │
│                                                              │
│  PATTERN 3: HIERARCHICAL (Supervisor-Worker)                 │
│                                                              │
│  [Supervisor Agent]                                          │
│  ├── "Classify this" → [Classifier Agent] → result          │
│  ├── "Extract fields" → [Extractor Agent] → result          │
│  └── "Validate" → [Validator Agent] → result                │
│  Supervisor decides what to delegate based on context.      │
└──────────────────────────────────────────────────────────────┘

When to Use Each Pattern

Pattern	Best For	Cost	Latency	Complexity
Sequential	Pipeline processing (classify → extract → act)	Medium (N agents × 1 call each)	Medium (sequential)	Low
Parallel	Independent tasks (classify + extract + sentiment)	High (N agents in parallel)	Low (parallel)	Medium
Hierarchical	Dynamic delegation (supervisor decides what's needed)	Highest (supervisor + workers)	High (supervisor waits)	High

You need to process emails: classify intent, extract entities, check sentiment, and determine priority. These are all independent — none depends on the others. Which pattern is best?

Parallel is best because the four tasks are independent — none needs the output of another. Running them simultaneously reduces latency (all finish in the time of the slowest, not the sum of all). Sequential would work but is slower (4 × latency). Hierarchical adds unnecessary supervisor overhead. A single agent with 4 tasks risks cognitive overload. Parallel: fan out to 4 specialized agents, fan in to merge results.

Specialized Agent Design

CLASSIFIER AGENT
  Tools: none (pure LLM reasoning)
  Prompt: "Classify email as: order, tracking, complaint, invoice, inquiry, other"
  Output: {category, confidence}

EXTRACTION AGENT
  Tools: search_carrier, lookup_rate
  Prompt: "Extract shipment fields from email. Use tools to look up missing data."
  Output: {origin, destination, rate, carrier, mc_number}

VALIDATION AGENT
  Tools: validate_address, check_credit
  Prompt: "Validate extracted data. Check addresses are real, carrier credit is good."
  Output: {valid, errors, warnings}

ACTION AGENT
  Tools: create_order, send_email
  Prompt: "Create order in TMS and send confirmation email."
  Output: {order_id, email_sent}

Cost Comparison

Approach	LLM Calls per Email	Tokens per Email	Cost per Email
Single agent (4 iterations)	4	3,200	$0.00048
Sequential multi-agent (4 agents)	4	2,000	$0.00030
Parallel multi-agent (4 agents)	4	2,000	$0.00030
Hierarchical (supervisor + 3 workers)	5	3,500	$0.00053

Multi-agent sequential/parallel is cheaper than single agent because each agent has a focused prompt (fewer tokens) and doesn't need multiple iterations.

Unlock the full lesson

You've read the first 2 sections. The rest of this lesson covers Build It, Use It, Ship It, Exercises, Key Terms, Common Pitfalls — plus a hands-on lab, quiz, and project artifact.

Create a free account to unlock Phase 0 and Phase 1 of every course — no credit card.