What is CrewAI?
CrewAI is a framework for orchestrating role-playing, autonomous AI agents. It allows you to create a "crew" of AI agents, each with a specific role, goal, and backstory, that work together to accomplish complex tasks.
Think of it as assembling a virtual team: a researcher who gathers information, a writer who creates content, and an editor who polishes the final output. Each agent brings expertise to their role, and together they produce results beyond what any single agent could achieve.
Why Use CrewAI?
CrewAI stands out for its simplicity and role-based approach:
- Intuitive design: Define agents by their roles, like hiring team members
- Autonomous collaboration: Agents figure out how to work together
- Quick to prototype: Get multi-agent systems running in minutes
- Flexible workflows: Sequential or hierarchical task execution
- Built-in memory: Agents remember context across tasks
The CrewAI Philosophy
Focus on the "what" (roles and tasks), not the "how" (agent coordination). CrewAI handles the collaboration logistics.
Core Concepts
1. Agents
An agent is an AI team member with:
- Role: Their job title (e.g., "Senior Researcher")
- Goal: What they're trying to achieve
- Backstory: Context that shapes their behavior
- Tools: Capabilities they can use (search, code, etc.)
2. Tasks
A task is a specific job to be done:
- Description: What needs to be accomplished
- Agent: Who is responsible
- Expected output: What success looks like
3. Crew
The crew brings agents and tasks together:
- Agents: The team members
- Tasks: The work to be done
- Process: How tasks are executed (sequential or hierarchical)
Getting Started
Installation
pip install crewai crewai-tools
Your First Crew
from crewai import Agent, Task, Crew, Process
# Create agents
researcher = Agent(
role="Senior Research Analyst",
goal="Find and analyze the latest AI trends",
backstory="""You are an expert researcher with years of experience
in analyzing technology trends. You're known for your thorough
research and clear insights.""",
verbose=True
)
writer = Agent(
role="Content Writer",
goal="Create engaging content about AI trends",
backstory="""You are a skilled writer who specializes in making
complex topics accessible. You write in a clear, engaging style.""",
verbose=True
)
# Create tasks
research_task = Task(
description="""Research the top 3 AI trends for 2024.
Focus on practical applications and business impact.""",
expected_output="A detailed report on top AI trends",
agent=researcher
)
writing_task = Task(
description="""Write a blog post based on the research.
Make it engaging and accessible for a general audience.""",
expected_output="A 500-word blog post",
agent=writer
)
# Create and run the crew
crew = Crew(
agents=[researcher, writer],
tasks=[research_task, writing_task],
process=Process.sequential, # Tasks run in order
verbose=True
)
result = crew.kickoff()
print(result)
Adding Tools to Agents
Tools give agents real capabilities:
from crewai_tools import SerperDevTool, WebsiteSearchTool
# Search tool
search_tool = SerperDevTool()
# Website scraping tool
web_tool = WebsiteSearchTool()
# Agent with tools
researcher = Agent(
role="Research Analyst",
goal="Find accurate information from reliable sources",
backstory="You are meticulous about fact-checking...",
tools=[search_tool, web_tool],
verbose=True
)
# The agent can now search the web and scrape websites!
Available Tools
- SerperDevTool: Google search via Serper API
- WebsiteSearchTool: Scrape and search websites
- FileReadTool: Read local files
- DirectoryReadTool: Read directory contents
- CodeInterpreterTool: Execute Python code
- Custom tools: Create your own!
Process Types
Sequential Process
Tasks execute one after another, each building on the previous:
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, writing_task, editing_task],
process=Process.sequential
)
# Research → Writing → Editing
Hierarchical Process
A manager agent coordinates the team:
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, writing_task, editing_task],
process=Process.hierarchical,
manager_llm=ChatOpenAI(model="gpt-4")
)
# Manager decides task order and delegation
Common Use Cases
Content Creation
Researcher → Writer → Editor pipeline for articles, blogs, reports.
Market Research
Gather competitive intelligence, analyze trends, generate reports.
Code Review
Developer writes, reviewer analyzes, QA validates.
Customer Support
Triage agent categorizes, specialist resolves, QA checks quality.
Data Analysis
Analyst explores data, statistician validates, presenter creates visuals.
Trip Planning
Researcher finds options, planner organizes, budgeter optimizes costs.
Real-World Example: Blog Post Crew
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool
search_tool = SerperDevTool()
# The Research Expert
researcher = Agent(
role="Senior Tech Researcher",
goal="Uncover cutting-edge developments in AI",
backstory="""You work at a leading tech think tank. Your passion
lies in identifying emerging trends and breaking down complex
topics for a general audience.""",
tools=[search_tool],
verbose=True
)
# The Content Creator
writer = Agent(
role="Tech Content Strategist",
goal="Craft compelling content on tech advancements",
backstory="""You are a renowned Content Strategist known for
insightful and engaging articles. You transform complex
concepts into compelling narratives.""",
verbose=True
)
# The Quality Guardian
editor = Agent(
role="Senior Editor",
goal="Ensure content is polished and publication-ready",
backstory="""With years of editing experience, you have a keen
eye for detail and a passion for clear, impactful writing.""",
verbose=True
)
# Define tasks
research = Task(
description="""Research the latest AI agent frameworks.
Focus on LangGraph, CrewAI, and AutoGen.
Compare their approaches and use cases.""",
expected_output="Comprehensive research notes with sources",
agent=researcher
)
write = Task(
description="""Write an engaging blog post based on the research.
Target: developers new to AI agents.
Length: 800-1000 words.
Include code examples where relevant.""",
expected_output="Complete blog post draft",
agent=writer
)
edit = Task(
description="""Edit the blog post for:
- Clarity and flow
- Technical accuracy
- Engaging introduction and conclusion
- Proper formatting""",
expected_output="Polished, publication-ready blog post",
agent=editor
)
# Assemble and run the crew
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research, write, edit],
process=Process.sequential,
verbose=True
)
result = crew.kickoff()
print("=== FINAL OUTPUT ===")
print(result)
CrewAI vs Other Frameworks
| Feature | CrewAI | AutoGen | LangGraph |
|---|---|---|---|
| Learning curve | Easy | Moderate | Steeper |
| Paradigm | Role-based | Conversation-based | Graph-based |
| Flexibility | Moderate | High | Very high |
| Best for | Quick prototypes | Collaborative dialog | Complex workflows |
| Setup time | Minutes | ~30 minutes | Hours |
Best Practices
- Detailed backstories: Rich context leads to better agent behavior
- Clear expected outputs: Tell agents exactly what success looks like
- Start sequential: Master sequential before trying hierarchical
- Limit crew size: 3-5 agents is usually optimal
- Use appropriate tools: Give agents only the tools they need
- Test incrementally: Test each agent individually before combining
- Monitor costs: Multi-agent systems use more tokens
Master CrewAI with Expert Mentorship
Our Agentic AI program covers CrewAI alongside other multi-agent frameworks. Build real AI teams with personalized guidance from industry experts.
Explore Agentic AI Program