CrewAI for Enterprise Multi-Agent Workflows

LangGraph gives you precise control over agent state and execution flow. CrewAI gives you a higher-level abstraction: define agents as roles with responsibilities, assign them tasks, and let the framework coordinate execution.

By mid-2026, CrewAI reported 60% Fortune 500 adoption — driven largely by how quickly product teams can design and explain multi-agent workflows without deep framework knowledge. The role metaphor maps to how teams already think about work division.

graph TD
    Crew[Content Research Crew\nProcess: Sequential] --> R[Researcher\nRole: Research Analyst\nTools: Search, Web]
    Crew --> W[Writer\nRole: Content Writer\nTools: none]
    Crew --> E[Editor\nRole: Editorial Lead\nTools: Search]
    R -->|research_task output| W
    W -->|writing_task output| E
    E -->|final article| OUT[Publication-ready article]
    R -.->|allow_delegation: false| R
    W -.->|allow_delegation: false| W
    E -.->|allow_delegation: true| R

---

The Core Abstractions

Agent: A role with a goal, backstory, and tool set. The LLM powering it is configurable.

Task: A specific piece of work assigned to an agent. Has a description, expected output, and optionally depends on other tasks.

Crew: A group of agents and tasks, with an execution process (sequential or hierarchical).

Process: Sequential (tasks run one after another) or Hierarchical (a manager agent coordinates other agents).

---

A Content Research and Publishing Workflow

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

# Configure models
sonnet = ChatAnthropic(model="claude-sonnet-4-6")
haiku = ChatAnthropic(model="claude-haiku-4-5-20251001")

# Tools
search_tool = SerperDevTool()
web_tool = WebsiteSearchTool()

# Define agents as roles
researcher = Agent(
    role="Research Analyst",
    goal="Find accurate, current information on the assigned topic",
    backstory="""You are a senior research analyst with expertise in technology and business.
    You know how to distinguish credible sources from noise and extract the key facts 
    that decision-makers need.""",
    tools=[search_tool, web_tool],
    llm=sonnet,
    verbose=True,
    allow_delegation=False  # researcher stays in their lane
)

writer = Agent(
    role="Content Writer",
    goal="Transform research findings into clear, engaging content",
    backstory="""You are a technical writer who explains complex topics to practitioner audiences.
    You write for engineers and business leaders who are past the basics — they want 
    substance, not summaries.""",
    tools=[],  # writer doesn't need search tools
    llm=sonnet,
    allow_delegation=False
)

editor = Agent(
    role="Editorial Lead",
    goal="Ensure content is accurate, well-structured, and meets publication standards",
    backstory="""You are a senior editor with a background in technical journalism.
    You catch factual errors, improve structure, and ensure the content serves the reader.""",
    tools=[search_tool],  # can verify facts
    llm=sonnet,
    allow_delegation=True  # can delegate verification to researcher
)

# Define tasks
research_task = Task(
    description="""Research the following topic thoroughly: {topic}
    
    Gather:
    - Key facts and statistics (with sources)
    - Recent developments in the last 6 months
    - Expert opinions or authoritative perspectives
    - Relevant examples or case studies
    
    Output a structured research brief with citations.""",
    expected_output="A structured research brief with key facts, sources, and recent developments",
    agent=researcher
)

writing_task = Task(
    description="""Using the research brief from the researcher, write a professional article 
    on {topic}.
    
    Requirements:
    - 600-900 words
    - Practitioner audience (engineers and technical managers)
    - Lead with the key insight, not background
    - Include at least 3 concrete examples or data points
    - No marketing language""",
    expected_output="A 600-900 word article ready for editorial review",
    agent=writer,
    context=[research_task]  # depends on research task output
)

editing_task = Task(
    description="""Review and improve the article draft.
    
    Check:
    - Factual accuracy (verify key claims)
    - Structure and flow
    - Tone consistency
    - Whether the lead delivers on its promise
    
    Return the final, publication-ready article with a brief edit summary.""",
    expected_output="Final article with edit notes",
    agent=editor,
    context=[writing_task]
)

# Assemble the crew
content_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    verbose=True
)

# Run
result = content_crew.kickoff(inputs={"topic": "EU AI Act compliance for engineering teams"})

---

Hierarchical Process for Complex Coordination

Sequential works for linear workflows. Hierarchical adds a manager agent that directs others:

from crewai import Agent, Task, Crew, Process

manager = Agent(
    role="Project Manager",
    goal="Coordinate the team to deliver a complete analysis on time and to specification",
    backstory="Experienced project manager who keeps teams aligned and resolves blockers.",
    llm=sonnet,
    allow_delegation=True  # manager must be able to delegate
)

# Specialist agents
data_analyst = Agent(
    role="Data Analyst",
    goal="Extract insights from quantitative data",
    backstory="Quantitative analyst specialising in business metrics.",
    tools=[],
    llm=haiku  # cheaper model for data work
)

strategy_consultant = Agent(
    role="Strategy Consultant", 
    goal="Provide strategic interpretation of findings",
    backstory="Senior consultant with experience in AI strategy.",
    tools=[search_tool],
    llm=sonnet
)

# With hierarchical process, the manager decides task assignment
analysis_crew = Crew(
    agents=[manager, data_analyst, strategy_consultant],
    tasks=[analysis_task, strategy_task, report_task],
    process=Process.hierarchical,
    manager_agent=manager,
    verbose=True
)

In hierarchical mode, the manager agent dynamically assigns work and can redirect agents based on intermediate results. Useful for complex, open-ended tasks where the work structure isn’t fully known upfront.

---

MCP Integration

CrewAI supports MCP servers as tool sources, connecting crews to your existing tool infrastructure:

from crewai_tools import MCPServerAdapter

# Connect to your MCP server
mcp_tools = MCPServerAdapter(
    server_url="http://your-mcp-server:8080",
    tools=["query_database", "read_confluence", "search_jira"]
)

research_agent = Agent(
    role="Enterprise Research Analyst",
    goal="Research using internal company data sources",
    backstory="Analyst with access to internal data systems.",
    tools=mcp_tools.get_tools(),  # MCP tools as CrewAI tools
    llm=sonnet
)

This makes your MCP server reusable across both LangGraph agents (covered in Day 2’s MCP post) and CrewAI agents without duplicating tool definitions.

---

Where CrewAI Excels Over LangGraph

CrewAI’s strength is explainability and design speed. When you need to present an agent architecture to stakeholders, “we have a Researcher, a Writer, and an Editor” is immediately understandable. The crew diagram maps to how humans understand team structures.

CrewAI’s limitation compared to LangGraph: less control over state management and execution flow. For workflows where you need fine-grained control over what state is passed between steps, where you need interrupt-resume with custom state, or where the execution graph has complex branching — LangGraph gives you more control.

The practical choice:

• Human-modelled workflows with role-based specialisation → CrewAI
• Complex state machines with precise control requirements → LangGraph
• Simple, linear agents → either, choose based on team familiarity

---

Day 27 of the Production Agentic AI series. Previous: Building Production Agents with LangGraph