crewai

• Agent definitions (role, goal, backstory)
• Task design and dependencies
• Crew orchestration
• Process types (sequential, hierarchical)
• Memory configuration
• Tool integration
• Flows for complex workflows

• Python 3.10+
• crewai package
• LLM API access

Basic Crew with YAML Config

Define agents and tasks in YAML (recommended)

When to use: Any CrewAI project

```python

# config/agents.yaml

researcher:

role: "Senior Research Analyst"

goal: "Find comprehensive, accurate information on {topic}"

backstory: |

You are an expert researcher with years of experience

in gathering and analyzing information. You're known

for your thorough and accurate research.

tools:

- SerperDevTool

- WebsiteSearchTool

verbose: true

writer:

role: "Content Writer"

goal: "Create engaging, well-structured content"

backstory: |

You are a skilled writer who transforms research

into compelling narratives. You focus on clarity

and engagement.

verbose: true

# config/tasks.yaml

research_task:

description: |

Research the topic: {topic}

Focus on:

1. Key facts and statistics

2. Recent developments

3. Expert opinions

4. Contrarian viewpoints

Be thorough and cite sources.

agent: researcher

expected_output: |

A comprehensive research report with:

- Executive summary

- Key findings (bulleted)

- Sources cited

writing_task:

description: |

Using the research provided, write an article about {topic}.

Requirements:

- 800-1000 words

- Engaging introduction

- Clear structure with headers

- Actionable conclusion

agent: writer

expected_output: "A polished article ready for publication"

context:

- research_task # Uses output from research

# crew.py

from crewai import Agent, Task, Crew, Process

from crewai.project import CrewBase, agent, task, crew

@CrewBase

class ContentCrew:

agents_config = 'config/agents.yaml'

tasks_config = 'config/tasks.yaml'

@agent

def researcher(self) -> Agent:

return Agent(config=self.agents_config['researcher'])

@agent

def writer(self) -> Agent:

return Agent(config=self.agents_config['writer'])

@task

def research_task(self) -> Task:

return Task(config=self.tasks_config['research_task'])

@task

def writing_task(self) -> Task:

return Task(config

```

Hierarchical Process

Manager agent delegates to workers

When to use: Complex tasks needing coordination

```python

from crewai import Crew, Process

# Define specialized agents

researcher = Agent(

role="Research Specialist",

goal="Find accurate information",

backstory="Expert researcher..."

)

analyst = Agent(

role="Data Analyst",

goal="Analyze and interpret data",

backstory="Expert analyst..."

)

writer = Agent(

role="Content Writer",

goal="Create engaging content",

backstory="Expert writer..."

)

# Hierarchical crew - manager coordinates

crew = Crew(

agents=[researcher, analyst, writer],

tasks=[research_task, analysis_task, writing_task],

process=Process.hierarchical,

manager_llm=ChatOpenAI(model="gpt-4o"), # Manager model

verbose=True

)

# Manager decides:

# - Which agent handles which task

# - When to delegate

# - How to combine results

result = crew.kickoff()

```

Planning Feature

Generate execution plan before running

When to use: Complex workflows needing structure

```python

from crewai import Crew, Process

# Enable planning

crew = Crew(

agents=[researcher, writer, reviewer],

tasks=[research, write, review],

process=Process.sequential,

planning=True, # Enable planning

planning_llm=ChatOpenAI(model="gpt-4o") # Planner model

)

# With planning enabled:

# 1. CrewAI generates step-by-step plan

# 2. Plan is injected into each task

# 3. Agents see overall structure

# 4. More consistent results

result = crew.kickoff()

# Access the plan

print(crew.plan)

```

❌ Vague Agent Roles

Why bad: Agent doesn't know its specialty.

Overlapping responsibilities.

Poor task delegation.

Instead: Be specific:

• "Senior React Developer" not "Developer"
• "Financial Analyst specializing in crypto" not "Analyst"

Include specific skills in backstory.

❌ Missing Expected Outputs

Why bad: Agent doesn't know done criteria.

Inconsistent outputs.

Hard to chain tasks.

Instead: Always specify expected_output:

expected_output: |

A JSON object with:

- summary: string (100 words max)

- key_points: list of strings

- confidence: float 0-1

❌ Too Many Agents

Why bad: Coordination overhead.

Inconsistent communication.

Slower execution.

Instead: 3-5 agents with clear roles.

One agent can handle multiple related tasks.

Use tools instead of agents for simple actions.

• Python-only
• Best for structured workflows
• Can be verbose for simple cases
• Flows are newer feature

Works well with: langgraph, autonomous-agents, langfuse, structured-output