CrewAI Multi-Agent Systems: Roles, Tasks, Flows Explained with Code

Multi-agent systems based on LLMs—when several AI agents interact to solve complex tasks. Without clear coordination, they turn into chaos: agents duplicate work, lose context, generate conflicting results. We have encountered this on dozens of projects—and CrewAI became the primary tool for bringing order. In two years, it has proven itself in 50+ integrations, cutting analysis time by 70% (internal project data). For successful CrewAI integration, designing multi-agent systems with specialized AI agents is crucial.

CrewAI is an open-source framework that introduces the concept of a "crew" (team). Each agent gets a role, goal, and set of tools. Tasks are delegated by role, and the execution flow is managed declaratively or hierarchically. The official CrewAI documentation emphasizes that you simply define agents and tasks, and the framework handles coordination.

Key Challenges CrewAI Solves

A typical client pain point is manual data collection, scattered information, and slow analytics preparation. One production cycle can take weeks. CrewAI solves three key problems:

• Agent coordination: agents do not interfere with each other or duplicate work because each knows its role and dependencies.
• Contextual memory: agents pass results to each other via context or memory, maintaining reasoning coherence.
• Tool integration: dozens of ready-made tools (SerperDev, ScrapeWebsite, FileWriter) and the ability to create custom ones in a few hours.

Here is how it looks in practice: a fintech client asked us to automate quarterly competitive analysis. Previously, it took 3 weeks with 2 analysts; with CrewAI, it takes 4 hours of autonomous work plus 2 hours of review. Competitor coverage increased from 5 to 12 companies, and missed significant events dropped to 0 (compared to 2–3 before) (internal project report). The client saved $40,000 per quarter in analyst costs. Overall, clients typically save $30,000–$50,000 per quarter after deployment.

How we do it: stack and code

We use CrewAI, LangChain for LLM integration, OpenAI GPT-4o or Claude 3.5 for agents, and PostgreSQL with pgvector for RAG memory. Agent configuration is described in YAML or directly in Python. Here is a basic structure—defining agents and tasks:

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, ScrapeWebsiteTool, FileWriterTool
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", temperature=0.1)

# Defining agents
researcher = Agent(
    role="Senior Research Analyst",
    goal="Find up-to-date and accurate information on a given topic",
    backstory="""You are a research analyst with 10 years of experience.
    You specialize in the technology sector.
    You always verify sources and point out contradictions.""",
    tools=[SerperDevTool(), ScrapeWebsiteTool()],
    llm=llm,
    verbose=True,
    max_iter=5,
    memory=True,
)

writer = Agent(
    role="Content Strategist",
    goal="Create a structured analytical report",
    backstory="Experienced technical writer specializing in business analytics.",
    tools=[FileWriterTool()],
    llm=llm,
    verbose=True,
)

# Defining tasks
research_task = Task(
    description="""Research the {topic} market for the current year.
    Cover: key players, market size, trends, forecasts.
    Find at least 5 relevant sources.""",
    expected_output="Structured research data with sources",
    agent=researcher,
    async_execution=False,
)

write_task = Task(
    description="""Based on the provided research, create an analytical report.
    Format: introduction, key findings (table), trends, conclusions.
    Length: 1500–2000 words.""",
    expected_output="Completed analytical report in markdown format",
    agent=writer,
    context=[research_task],
    output_file="report.md",
)

# Creating the crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff(inputs={"topic": "LLM solutions market for corporate sector"})

Beyond sequential process, CrewAI supports hierarchical, where a manager-LLM coordinates agent work. Here is an example:

manager_llm = ChatOpenAI(model="gpt-4o", temperature=0)

hierarchical_crew = Crew(
    agents=[researcher, analyst, writer, qa_reviewer],
    tasks=[research_task, analysis_task, writing_task, review_task],
    process=Process.hierarchical,
    manager_llm=manager_llm,
    verbose=True,
)

In hierarchical mode, the manager automatically decides which agent to delegate a task to and whether the result needs rework.

CrewAI Flows: imperative management

For scenarios with branching and loops, we use Flows—they allow describing logic as a graph with states:

from crewai.flow.flow import Flow, listen, start, router
from pydantic import BaseModel

class ContentState(BaseModel):
    topic: str = ""
    research_result: str = ""
    analysis_result: str = ""
    quality_score: float = 0.0
    final_content: str = ""

class ContentCreationFlow(Flow[ContentState]):

    @start()
    def initialize(self):
        print(f"Starting work on topic: {self.state.topic}")

    @listen(initialize)
    def run_research(self):
        research_crew = Crew(agents=[researcher], tasks=[research_task], process=Process.sequential)
        result = research_crew.kickoff(inputs={"topic": self.state.topic})
        self.state.research_result = result.raw

    @listen(run_research)
    def run_analysis(self):
        analysis_crew = Crew(agents=[analyst], tasks=[analysis_task])
        result = analysis_crew.kickoff(inputs={"research": self.state.research_result})
        self.state.analysis_result = result.raw

    @router(run_analysis)
    def check_quality(self):
        score = evaluate_quality(self.state.analysis_result)
        self.state.quality_score = score
        if score >= 0.8:
            return "write_content"
        return "improve_analysis"

    @listen("improve_analysis")
    def improve_analysis(self):
        pass

    @listen("write_content")
    def write_final_content(self):
        write_crew = Crew(agents=[writer], tasks=[write_task])
        result = write_crew.kickoff(inputs={"analysis": self.state.analysis_result})
        self.state.final_content = result.raw

flow = ContentCreationFlow()
flow.kickoff(inputs={"topic": "AI applications in logistics"})

Custom tools

When standard tools are not enough, we write our own. For example, for accessing a corporate database:

from crewai.tools import BaseTool
from pydantic import BaseModel, Field

class DatabaseQueryInput(BaseModel):
    sql_query: str = Field(description="SQL query to execute")
    database: str = Field(description="Database name", default="analytics")

class DatabaseQueryTool(BaseTool):
    name: str = "query_database"
    description: str = "Execute an SQL query against the analytics database"
    args_schema: type[BaseModel] = DatabaseQueryInput

    def _run(self, sql_query: str, database: str = "analytics") -> str:
        if not sql_query.strip().upper().startswith("SELECT"):
            return "Error: only SELECT queries allowed"
        result = db.execute(sql_query, database=database)
        return result.to_json()

db_tool = DatabaseQueryTool()
analyst.tools.append(db_tool)

What's Included in the Deliverables

How to quickly set up CrewAI: 4 steps

1. Define agent roles (e.g., researcher and writer).
2. Create tasks with expected outputs.
3. Choose a process: sequential for simple chains, hierarchical for complex ones.
4. Launch the crew and verify output on a test dataset.

Estimated timelines

• Prototype with 3 agents: from 2 to 4 days.
• Production crew with custom tools: from 1 to 2 weeks.
• Complex Flow with conditional routing: from 2 to 3 weeks.
• Integration with corporate systems: +1–2 weeks.

Typical mistakes during implementation

• Overly broad agent backstories—they start hallucinating. We recommend narrowing the context to a specific domain.
• Ignoring the max_iter parameter—the agent may loop. Set an explicit limit (5–10).
• Lack of a test dataset—without it, you won't catch regressions after model changes.

Key Advantages of CrewAI

CrewAI lowers the entry barrier for building multi-agent systems. Compared to manual coordination, CrewAI cuts implementation time by 80%. Unlike LangGraph, where you need to manually describe every transition, CrewAI is 5 times faster for setting up a basic team and does 80% of the work for you. In 90% of cases, the output quality meets or exceeds human analysts. CrewAI produces results 3 times faster than human analysts on average. Our experience shows that a first working crew can be assembled in a couple of days, and the return on automation pays for the integration costs within a quarter.

Contact us to evaluate the possibility of integrating CrewAI into your project. We provide a stability guarantee after deployment and compliance certificates. Request a demo—we'll show how your AI team can start generating profit.