Lesson 10 — A Multi-Agent Crew

CrewAI's sweet spot: a planner + worker + reviewer trio that collaborates on a brief.

Agents Module 5 CrewAI Multi-Agent

Why this is CrewAI's sweet spot

• Three distinct roles — planner, worker, reviewer — each with its own persona and goal.
• Artefacts flow between them — plan → draft → review — and each downstream role can see the upstream ones via context=[...].
• Each role uses a different toolset — only the planner needs topic_lookup; the worker and reviewer work from artefacts alone.
• The team structure is the design — neither tool-heavy single-agent (M2) nor a graph (M3) nor pure handoff (M4) captures it as cleanly.

Hits every condition on L09 Slide 11's “Pick it when” list.

The crew we're building

Real example topic: “What changed in Linux kernel 6.14's networking stack?”

Three agents, three artefacts, one sequential process — the canonical CrewAI shape.

The three roles

The artefact flow

topic
  │
  ▼
[Planner] ──outline──► [Worker] ──draft──► [Reviewer] ──review──► final
                              │
                              └──outline-also visible via context─┐

Sequential process; each downstream task context=[...] the upstream ones it needs.

Why three agents, not one?

• Separation of concerns. Planning, drafting, and reviewing are three modes of thinking; doing them all in one prompt risks each weakening the others.
• Per-agent models. You can route the planner and reviewer to Sonnet (judgement) and the worker to Haiku (transformation) for a real cost win — covered in L10's homework.
• Per-agent tools. Only the planner has access to topic_lookup (a mocked PKB-style tool). Worker and reviewer have no tools — they work from artefacts alone.
• Reviewability. When something goes wrong in the final brief, the per-task outputs tell you which agent made the mistake.

The three tasks

plan_task = Task(
    description="Plan a brief on {topic}. Output 3 section headings, one line each.",
    expected_output="3 lines, each a section heading.",
    agent=planner,
)

draft_task = Task(
    description="Draft a brief on {topic} following the planner's outline EXACTLY.",
    expected_output="A 150-250 word brief with the 3 sections from the outline.",
    agent=worker,
    context=[plan_task],
)

review_task = Task(
    description="Review the draft for unsupported claims or unclear sentences.",
    expected_output="A short review: list 0-3 issues, or write 'no issues found'.",
    agent=reviewer,
    context=[plan_task, draft_task],
)

context=[plan_task, draft_task] on the reviewer means the reviewer sees both — useful for catching cases where the draft diverged from the plan.

The crew assembly

crew = Crew(
    agents=[planner, worker, reviewer],
    tasks=[plan_task, draft_task, review_task],
    process=Process.sequential,
    verbose=True,
)
result = crew.kickoff(inputs={"topic": question})

~6 lines of glue. The collaboration is in the agent + task definitions above — the Crew just runs them.

The mocked topic_lookup tool

@tool
def topic_lookup(topic: str) -> str:
    """Look up a topic in the in-process knowledge base."""
    return KB.get(topic.lower(), "no entry found in KB")

Small dict of pre-seeded entries so the planner has something to ground the outline on. Same shape as M2's L04 mocked tools. The crew runs deterministically.

A real run trace

[Planner    ] Section 1: io_uring zero-copy TX
              Section 2: BIG TCP default for IPv4
              Section 3: tc-bpf flow-tracking kfuncs

[Worker     ] (draft of ~200 words following the outline)

[Reviewer   ] 1 issue: section 3 mentions "kfunc family"
              without naming any. Consider citing.

Three LLM calls (one per agent) plus any tool calls by the planner. Total: ~$0.04–$0.08 with Sonnet across the team.

Structured-output pattern in CrewAI

• CrewAI offers output_json= / output_pydantic= on Task for typed outputs.
• We use output_pydantic=BriefDraft on draft_task so the worker's output is a BriefDraft(title, sections) object.
• This is CrewAI's answer to M2's write_report final-answer-tool pattern: a tax of one Pydantic model definition per typed task, in exchange for structured outputs.

Cost and latency profile

• 3 turns minimum (one per agent), can be more if the planner calls topic_lookup multiple times.
• Cost: ~$0.04–$0.08 per brief with Sonnet for all three. (Cf. M2's single-agent tool-heavy: ~$0.02–$0.05.) Multi-agent isn't free.
• Latency: ~20–35 seconds end-to-end (sequential, no parallelism between agents). The trade-off for clarity.

What's left to wire (Module 6 hook)

Recap & what's next

• 3 roles is CrewAI's sweet spot. Planner + worker + reviewer is the canonical multi-agent shape — distinct personas, distinct tools, sequential collaboration.
• context=[...] is the artefact flow primitive. Each downstream task declares which upstream artefacts it can see; the framework wires them in.
• Pydantic output for structured drafts. One model definition per typed task gives you parsable outputs without an extra schema layer.