When One Agent Isn't Enough

The research agent from Lesson 3 works great for focused tasks. But what happens when the task has multiple distinct phases that require different expertise?

"Research AI agent trends, write a technical blog post, then edit it for clarity and SEO" — that's three different skills. A single agent trying to do all three will produce mediocre results at each stage. The research gets shallow because the agent is also thinking about writing. The writing suffers because the agent is also thinking about SEO.

Multi-agent systems solve this by specialization. Instead of one general-purpose agent, you create a team of focused agents — each with a specific role, specific tools, and specific expertise. A researcher researches. A writer writes. An editor edits. They pass work between them like a real team.

CrewAI is the framework that makes this pattern practical.

CrewAI's Mental Model

CrewAI uses a workplace metaphor that maps surprisingly well to agent design:

Agent = A team member with a role, a goal, and a backstory that shapes its behavior
Task = A specific piece of work assigned to an agent, with a description and expected output
Crew = The team of agents working together, with a defined process (sequential, hierarchical, or autonomous)

The backstory isn't fluff. It's a prompt engineering technique that significantly improves output quality. An agent with the backstory "You've been a senior tech journalist at The Verge for 8 years" writes differently than one with "You are a helpful assistant."

Setup

pip install crewai crewai-tools

CrewAI works with OpenAI, Anthropic, Google, and local models. Set your preferred API key:

export OPENAI_API_KEY="your-key-here"
# Or for Claude:
# export ANTHROPIC_API_KEY="your-key-here"

Building a Content Production Crew

Let's build a three-agent crew that researches a topic, writes a technical article, and edits it for quality. This mirrors an actual content production workflow.

Step 1: Define the Agents

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, WebsiteSearchTool

# Tool: web search (requires SERPER_API_KEY env var)
search_tool = SerperDevTool()
web_reader = WebsiteSearchTool()

# Agent 1: The Researcher
researcher = Agent(
    role="Senior Technology Researcher",
    goal="Find comprehensive, accurate, and current information on the given topic",
    backstory="""You're a senior research analyst with 10 years of experience
    in AI and developer tools. You're known for finding information others miss
    and always verifying claims against multiple sources. You never speculate —
    every finding is backed by a source.""",
    tools=[search_tool, web_reader],
    verbose=True,
    allow_delegation=False  # Researchers don't delegate
)

# Agent 2: The Writer
writer = Agent(
    role="Technical Content Writer",
    goal="Transform research into engaging, technically accurate articles",
    backstory="""You're a technical writer who spent 5 years as a software
    engineer before switching to writing. You explain complex topics clearly
    without dumbing them down. Your articles are known for practical examples
    and honest assessments — you always mention limitations alongside benefits.""",
    verbose=True,
    allow_delegation=False
)

# Agent 3: The Editor
editor = Agent(
    role="Senior Technical Editor",
    goal="Ensure articles are accurate, well-structured, and engaging",
    backstory="""You're a senior editor who reviews technical content for
    accuracy, clarity, and reader engagement. You catch factual errors,
    fix awkward phrasing, and ensure the article flows logically. You're
    especially good at cutting unnecessary fluff.""",
    verbose=True,
    allow_delegation=False
)

Step 2: Define the Tasks

# Task 1: Research
research_task = Task(
    description="""Research the current state of AI agent frameworks in 2026.
    Focus on: LangGraph, CrewAI, AutoGen, and Mastra.
    For each framework, find:
    - Primary use case and architecture approach
    - GitHub stars and community size
    - Key strengths and weaknesses
    - Notable production deployments
    Compile findings into a structured research brief.""",
    expected_output="A detailed research brief covering 4 frameworks with stats, strengths, weaknesses, and sources",
    agent=researcher
)

# Task 2: Write (depends on research)
writing_task = Task(
    description="""Using the research brief, write a 1500-word technical article
    comparing AI agent frameworks. The article should:
    - Open with a compelling hook (NOT 'In the world of AI...')
    - Include a comparison table
    - Give a clear recommendation for different use cases
    - Include code snippets showing basic usage of each framework
    - End with practical advice for choosing a framework""",
    expected_output="A complete 1500-word technical article in markdown format",
    agent=writer,
    context=[research_task]  # Writer receives researcher's output
)

# Task 3: Edit (depends on writing)
editing_task = Task(
    description="""Review and improve the article:
    - Fix any factual inaccuracies
    - Improve clarity and flow
    - Cut fluff and redundancy
    - Ensure code examples are syntactically correct
    - Add a compelling title and meta description
    - Verify the article is between 1200-1800 words""",
    expected_output="The final polished article with title and meta description",
    agent=editor,
    context=[writing_task]  # Editor receives writer's output
)

Step 3: Assemble and Run the Crew

# Create the crew with sequential process
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,  # Tasks execute in order
    verbose=True
)

# Run the crew
result = crew.kickoff()
print(result)

When you run this, you'll see each agent working in sequence: the researcher searches the web and compiles findings, the writer takes those findings and produces an article, and the editor polishes the final draft. Each agent's output automatically becomes context for the next.

Process Types: Sequential vs. Hierarchical

The example above uses Process.sequential — tasks run in order. CrewAI also supports two other modes:

Hierarchical Process: A manager agent automatically delegates tasks to the most appropriate agent. You don't define the task order — the manager decides.

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.hierarchical,
    manager_llm=ChatOpenAI(model="gpt-4o", temperature=0),
    verbose=True
)

Hierarchical is more flexible but less predictable. The manager might ask the researcher to fact-check the writer's claims, or send the article back for revision. Good for complex workflows, harder to debug.

CrewAI Flows: Event-Driven Orchestration

For more complex workflows, CrewAI introduced Flows — an event-driven orchestration layer:

from crewai.flow.flow import Flow, listen, start

class ContentFlow(Flow):
    @start()
    def research_phase(self):
        """Initial research — triggers automatically."""
        result = research_crew.kickoff()
        return result.raw

    @listen(research_phase)
    def writing_phase(self, research_brief):
        """Triggered when research completes."""
        # Pass research as context to writing crew
        result = writing_crew.kickoff(
            inputs={"research": research_brief}
        )
        return result.raw

    @listen(writing_phase)
    def quality_check(self, article):
        """Triggered when writing completes."""
        if len(article.split()) < 500:
            # Article too short — send back for expansion
            return self.writing_phase(self.state["research"])
        return article

flow = ContentFlow()
final_article = flow.kickoff()

Flows let you build conditional logic, loops, and branching — things that are awkward with the basic Crew API.

Shared Memory: How Agents Collaborate

CrewAI includes built-in memory that agents share:

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    memory=True,  # Enable shared memory
    verbose=True
)

With memory enabled, agents can access:

Short-term memory: Recent interactions and outputs from the current run
Long-term memory: Learnings from previous runs (what worked, what didn't)
Entity memory: Persistent knowledge about specific entities (people, tools, companies) encountered across runs

This means your editor can reference the original research findings directly, not just the writer's interpretation of them. And across runs, agents learn — the researcher remembers which sources were reliable, the writer learns which styles the editor prefers.

When to Use CrewAI vs. LangGraph

Use CrewAI When	Use LangGraph When
Task has 2+ distinct phases requiring different skills	Single agent with complex tool-calling logic
You want role-based specialization	You need fine-grained control over execution flow
The workflow is mostly linear (sequential tasks)	The workflow has complex branching and loops
You want built-in memory and delegation	You need custom state management
Rapid prototyping of multi-agent workflows	Production systems requiring maximum control

They're not mutually exclusive. Some production systems use LangGraph for individual agent logic and CrewAI for orchestrating multiple agents. Use whatever fits your task.

For more AI agent frameworks and tools, explore tools.skila.ai and repos.skila.ai.

Multi-Agent Systems with CrewAI

Related Resources