Agent Frameworks and Orchestration

🔄 Quick Recall: In the previous lesson, you added guardrails, human checkpoints, and monitoring to make agents safe. Now let’s scale up — from single agents to systems where multiple specialized agents collaborate.

From One Agent to Many

A single agent can handle most tasks. But some workflows benefit from specialization:

The generalist problem: An agent tasked with “research the market, analyze the data, write the report, and design the presentation” must be good at four very different things. Its system prompt becomes bloated. Its tool set is overly broad. Quality suffers because no single prompt can optimize for research AND analysis AND writing AND design.

The specialist solution: Four agents, each optimized for one role. The researcher finds data. The analyst processes it. The writer creates the report. The designer formats the presentation. An orchestrator coordinates them.

This is how high-performing human teams work — and it’s how the best agent systems work too.

Multi-Agent Architectures

Hub-and-spoke (Orchestrator pattern)

One orchestrator agent manages several specialist agents:

ORCHESTRATOR → Research Agent → returns findings
ORCHESTRATOR → Analysis Agent → returns insights
ORCHESTRATOR → Writing Agent → returns report
ORCHESTRATOR → Review Agent → returns feedback
ORCHESTRATOR → assembles final output

Best for: workflows with clear stages and a defined output.

Pipeline (Assembly line)

Each agent passes its output to the next agent in sequence:

Research Agent → Analysis Agent → Writing Agent → Review Agent → Final Output

Best for: linear workflows where each stage transforms the previous stage’s output.

Debate (Adversarial review)

Two or more agents argue different positions, then a judge agent synthesizes:

Agent A: Argues for Option X
Agent B: Argues for Option Y
Judge Agent: Evaluates both arguments, makes final recommendation

Best for: decision-making tasks where considering multiple perspectives improves quality.

✅ Quick Check: What role does the orchestrator agent play in the hub-and-spoke architecture?

The orchestrator receives the overall goal, decomposes it into sub-tasks, assigns each to the right specialist agent, monitors progress, handles failures, and assembles the final output. It’s the coordinator that ensures all the pieces come together into a coherent result.

Designing Specialist Agents

Each specialist agent gets a focused system prompt:

Design a team of 4 specialist agents for a market analysis project:

AGENT 1 — RESEARCHER:
- Role: Find and collect market data from multiple sources
- Tools: web search, document reader
- Output: structured data collection with sources

AGENT 2 — ANALYST:
- Role: Process data, find patterns, generate insights
- Tools: code execution (for calculations), data formatter
- Output: analysis with charts and key findings

AGENT 3 — WRITER:
- Role: Transform analysis into a polished report
- Tools: write_file
- Output: structured report with executive summary

AGENT 4 — REVIEWER:
- Role: Check facts, find gaps, suggest improvements
- Tools: web search (for verification), read_file
- Output: feedback with specific issues and recommendations

For each agent, write:
1. System prompt (focused on their specific role)
2. Tool set (minimum needed for their role)
3. Input expectations (what they receive from previous agents)
4. Output format (what they deliver to the next agent)
5. Quality criteria (how they evaluate their own work)

Agent Communication

Agents need to pass information effectively. Define clear handoff formats:

HANDOFF FORMAT (between agents):

FROM: [Agent Name]
TO: [Next Agent Name]
TASK_ID: [tracking identifier]
STATUS: complete | partial | failed
SUMMARY: [1-2 sentence description of what was done]
OUTPUT: [the actual deliverable]
CONFIDENCE: [high | medium | low]
NOTES: [anything the next agent should know — gaps, uncertainties, special cases]
FLAGS: [issues that need human review]

This structured format prevents information loss between agents and makes debugging easier.

Framework Overview

For those who want to build multi-agent systems, several frameworks exist:

No-code/low-code options:

• Claude Projects with multiple “custom instructions” configurations
• Custom GPTs that call other GPTs via actions
• Automation platforms (Make, n8n) with AI steps in workflows

Developer frameworks:

• LangGraph — builds agent workflows as graphs with nodes and edges
• CrewAI — defines agents with roles, goals, and backstories that collaborate
• AutoGen — Microsoft’s framework for multi-agent conversations
• Anthropic’s Agent SDK — native support for tool use and multi-step agents

I want to build a multi-agent system for [task]. Compare these approaches:

1. No-code: Using Claude Projects + automation platform
2. Low-code: Using an automation platform with AI nodes
3. Full code: Using a framework like CrewAI or LangGraph

For my use case, which approach offers the best balance of:
- Ease of building
- Flexibility and customization
- Reliability for production use
- Cost efficiency

Orchestration Patterns

Sequential orchestration: The orchestrator runs agents one after another, each building on the previous output.

Parallel orchestration: The orchestrator runs independent agents simultaneously, then combines results.

Conditional orchestration: The orchestrator chooses which agents to run based on the task characteristics. “If the data is quantitative, route to the data analyst. If qualitative, route to the content analyst.”

Iterative orchestration: The orchestrator loops between agents. “Writer produces draft → Reviewer gives feedback → Writer revises → Reviewer re-evaluates → repeat until quality threshold met.”

When NOT to Use Multi-Agent Systems

Multi-agent adds complexity. Don’t use it when:

• A single agent handles the task well
• The overhead of inter-agent communication exceeds the benefit
• Debugging distributed failures would be harder than the problem
• The task doesn’t naturally decompose into distinct specialist roles

The rule: start with one agent. Only add agents when you can identify clear specializations that improve quality or speed.

Exercise: Design a Multi-Agent System

Design (on paper) a multi-agent system for one of these tasks:

Option A: Content marketing pipeline — research trending topics, write blog posts, create social media versions, schedule publishing.

Option B: Sales intelligence — research prospects, analyze their companies, personalize outreach messages, track responses.

Option C: Code review pipeline — analyze code changes, check for bugs, evaluate performance, suggest improvements, write review summary.

For your chosen task:

1. Define 3-4 specialist agents with roles and tools
2. Choose an architecture (hub-and-spoke, pipeline, or hybrid)
3. Design the handoff format between agents
4. Identify where human checkpoints belong
5. Define the orchestrator’s logic

Key Takeaways

• Multi-agent systems use specialized agents that are each optimized for a specific role — research, analysis, writing, review
• Three main architectures: hub-and-spoke (orchestrator manages all), pipeline (sequential handoffs), debate (adversarial improvement)
• The orchestrator coordinates the workflow: assigns tasks, monitors progress, handles failures, assembles output
• Structured handoff formats prevent information loss between agents
• Frameworks range from no-code (Claude Projects, automation tools) to full code (LangGraph, CrewAI)
• Don’t over-engineer: start with a single agent and only add agents when specialization clearly improves results

Up Next: In the final lesson, you’ll build a complete, production-ready agent system from scratch — applying everything you’ve learned across the entire course.