0% complete

Agent Track Hard 1-2 days

Multi-Agent Orchestration

Build an orchestrator that coordinates specialized sub-agents. This mirrors Tenzai's Moses/Bonzai architecture.

🎯 The Mission

Tenzai's architecture uses a Master Agent (Moses) that orchestrates specialized Sub-Agents (Bonzai for exploitation, Morty for context, Rico for code analysis). Understanding this pattern is crucial.

Build a simplified multi-agent system where a coordinator delegates to specialists. Experience the challenges of message passing, context sharing, and result aggregation.

Tenzai's Multi-Agent Architecture

TENZAI AGENT HIERARCHY

                    ┌─────────────────┐
                    │   ORCHESTRATOR  │
                    │     (Moses)     │
                    └────────┬────────┘
                             │
            ┌────────────────┼────────────────┐
            │                │                │
            ▼                ▼                ▼
    ┌───────────────┐ ┌───────────────┐ ┌───────────────┐
    │    BONZAI     │ │    MORTY      │ │     RICO      │
    │  (Exploiter)  │ │  (Context)    │ │ (Code Expert) │
    └───────────────┘ └───────────────┘ └───────────────┘

Your Task: Research & Writing System

Build a multi-agent system for content creation with these specialists:

🔍 Researcher Agent

Specialist

Gathers information from the web, finds relevant sources, extracts key facts. Has access to web_search and read_url tools.

✍️ Writer Agent

Specialist

Takes research and produces polished content. Focuses on structure, clarity, and engagement. No external tools—just writing.

📝 Editor Agent

Specialist

Reviews and improves content. Checks for accuracy, tone, and completeness. Can request revisions from the Writer.

🎯 Coordinator Agent

Orchestrator

Receives user requests, breaks them into tasks, delegates to specialists, aggregates results, and returns final output.

Key Challenge: How does the Coordinator pass context between agents? How do you handle failures? When should the Editor request revisions vs accept the draft?

Implementation Approaches

Approach 1: Simple Sequential (Beginner)

async def run_pipeline(user_request: str):
    # 1. Coordinator plans the work
    plan = await coordinator.run(f"Plan research for: {user_request}")
    
    # 2. Researcher gathers info
    research = await researcher.run(plan.research_queries)
    
    # 3. Writer creates draft
    draft = await writer.run(f"Write based on: {research}")
    
    # 4. Editor reviews
    final = await editor.run(f"Review and improve: {draft}")
    
    return final

Approach 2: Message-Passing (Intermediate)

class AgentMessage(BaseModel):
    from_agent: str
    to_agent: str
    content: str
    message_type: str  # "request", "response", "revision"

class Coordinator:
    def __init__(self):
        self.agents = {
            "researcher": ResearcherAgent(),
            "writer": WriterAgent(),
            "editor": EditorAgent(),
        }
        self.message_history: list[AgentMessage] = []
    
    async def run(self, user_request: str):
        # Coordinator decides which agent to call
        while not self.is_complete():
            next_action = await self.decide_next_action()
            result = await self.agents[next_action.agent].run(
                next_action.input,
                context=self.message_history
            )
            self.message_history.append(result)

Approach 3: LangGraph Multi-Agent (Advanced)

from langgraph.graph import StateGraph

class MultiAgentState(BaseModel):
    messages: list[BaseMessage]
    research: str | None = None
    draft: str | None = None
    final: str | None = None
    revision_count: int = 0

def create_multi_agent_graph():
    workflow = StateGraph(MultiAgentState)
    
    workflow.add_node("coordinator", coordinator_node)
    workflow.add_node("researcher", researcher_node)
    workflow.add_node("writer", writer_node)
    workflow.add_node("editor", editor_node)
    
    # Coordinator routes to specialists
    workflow.add_conditional_edges(
        "coordinator",
        route_to_specialist,
        {
            "research": "researcher",
            "write": "writer",
            "edit": "editor",
            "done": END
        }
    )
    
    # Specialists return to coordinator
    for agent in ["researcher", "writer", "editor"]:
        workflow.add_edge(agent, "coordinator")
    
    return workflow.compile()

✓ Success Criteria

System has at least 2 specialized agents + 1 coordinator
Coordinator correctly routes tasks to specialists
Context/results flow between agents appropriately
System handles at least one "revision" loop (Editor → Writer → Editor)
Final output combines work from multiple agents
You can explain the tradeoffs of your approach

Stretch Goals

Add parallel execution: Research multiple topics simultaneously
Implement agent memory: Agents remember context across invocations
Add human-in-the-loop: Pause for user approval at key points
Build a visualization of agent interactions (message flow diagram)
Compare your architecture to Tenzai's Moses/Bonzai in the real codebase

Reflection Questions

How did you decide what context to pass between agents?
What happens when a specialist agent fails? How do you handle it?
How would you add a new specialist agent? What would need to change?
What are the tradeoffs between simple sequential vs graph-based orchestration?

← Previous: LangGraph Back to Training →

Multi-Agent Orchestration

🎯 The Mission

Tenzai's Multi-Agent Architecture

Your Task: Research & Writing System

🔍 Researcher Agent

✍️ Writer Agent

📝 Editor Agent

🎯 Coordinator Agent

Implementation Approaches

Approach 1: Simple Sequential (Beginner)

Approach 2: Message-Passing (Intermediate)

Approach 3: LangGraph Multi-Agent (Advanced)

Resources

📖 Anthropic's Multi-Agent System

🎓 LangGraph Multi-Agent

💻 GPT Researcher

🎓 Agent Supervisor Pattern

✓ Success Criteria

📋 Progress Checklist

Stretch Goals

Reflection Questions