CrewAI in Python: Coordinating Teams of AI Agents

Get Started With CrewAI in Python

Before you dive into building multi-agent systems with CrewAI, you’ll need to install it and set up an API key for your chosen language model provider. This tutorial uses Google’s Gemini model, which you can access for free through Google AI Studio.

You can install CrewAI from PyPI using pip. Before running the command below, you should create and activate a virtual environment. CrewAI requires Python 3.10 to 3.13, so run python --version first—installing on Python 3.14 or later will silently resolve to a much older CrewAI release and then fail to build:

$ python-mpipinstall'crewai[tools,google-genai]'

This installs CrewAI’s core framework, the native Google Gemini provider, and prebuilt tools like web scraping that agents can use during their work.

You’ll need a Gemini API key to run the examples in this tutorial. If you don’t have one yet, then head over to Google AI Studio to sign in with your Google account and generate an API key for free.

Once you have your API key, set it as an environment variable:

• Windows
• Linux + macOS

PS> $ENV:GEMINI_API_KEY = "your-gemini-api-key-here"

$ exportGEMINI_API_KEY="your-gemini-api-key-here"

With your environment variable set, CrewAI is ready to connect to Gemini in your projects.

To get started with CrewAI, you can create a single agent that acts as a travel advisor:

fromcrewaiimport LLM, Agent, Crew, Task

llm = LLM(model="gemini/gemini-2.5-flash")

travel_agent = Agent(
    role="Travel Advisor",
    goal="Provide helpful travel recommendations",
    backstory=(
        "You're an experienced travel advisor who has visited"
        " over fifty countries and specializes in budget-friendly"
        " adventure travel."
    ),
    llm=llm,
    verbose=True,
)

task = Task(
    description="Suggest three budget-friendly destinations in Southeast Asia",
    expected_output="A short list of three destinations with brief descriptions",
    agent=travel_agent,
)

crew = Crew(agents=[travel_agent], tasks=[task])
result = crew.kickoff()
print(result.raw)

In this example, you import the Agent, Task, Crew, and LLM classes from crewai. Agents are the primary building blocks for multi-agent systems in CrewAI. You create an LLM instance pointing to Google’s Gemini model, then create an agent by passing three required arguments plus the llm parameter.

The role tells the agent what it is. The goal guides what it tries to accomplish. The backstory provides context that shapes how it responds. These three parameters work together to give your agent a personality and expertise area.

Build Your First Multi-Agent Team

A single agent is useful for understanding the basics, but CrewAI really shines when you combine multiple agents into a coordinated team. You’ll see how specialized agents working together outperform a single agent trying to do everything. In this section, you’ll build a two-agent crew—a researcher and a writer—that work in sequence on a renewable-energy article.

fromcrewaiimport LLM, Agent, Crew, Process, Task

llm = LLM(model="gemini/gemini-2.5-flash")

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive information about a given topic",
    backstory=(
        "You're a seasoned research analyst with a knack for"
        " uncovering the most relevant and accurate information."
        " You're known for your thorough and well-organized research."
    ),
    llm=llm,
)

writer = Agent(
    role="Content Writer",
    goal="Write clear, engaging content based on research findings",
    backstory=(
        "You're an experienced writer who excels at transforming"
        " complex research into accessible, well-structured articles"
        " that readers enjoy."
    ),
    llm=llm,
)

# ...

research_task = Task(
    description="Research the latest trends in renewable energy technology",
    expected_output=(
        "A detailed list of the top five renewable energy trends"
        " with explanations"
    ),
    agent=researcher,
)

writing_task = Task(
    description="Write a short article based on the research findings",
    expected_output=(
        "A well-structured article of about three hundred words"
        " on renewable energy trends"
    ),
    agent=writer,
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Control Task Dependencies Explicitly

The automatic data flow you saw in the previous section works great for simple two-task sequences. But what happens when you have three or more tasks, and not every task depends on the one immediately before it? You’ll need explicit control over which outputs feed into which tasks.

The context parameter gives you fine-grained control over task dependencies.

Continuing with the researcher and writer agents from the previous section, update your existing script—optionally saving it under a new filename to keep things tidy:

# ...

research_task = Task(
    description=(
        "Research the current state of electric vehicle adoption"
        " worldwide"
    ),
    expected_output=(
        "A bullet-point list of key statistics and trends"
        " in EV adoption"
    ),
    agent=researcher,
)

writing_task = Task(
    description=(
        "Using the provided research, write a concise summary article"
        " about electric vehicle adoption"
    ),
    expected_output="A two-hundred-word article summarizing EV adoption trends",
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

The key line here is context=[research_task]. This explicitly tells CrewAI that writing_task depends on research_task and should receive its output as context. While this happens automatically in a two-task crew, the context parameter becomes essential when you have more complex workflows.

For example, imagine you have two research tasks running in parallel with async_execution=True. You could have a writing task that depends on both via context=[task_a, task_b]. The writing task won’t start until both research tasks complete. This gives you precise control over how your agents coordinate.

The interactive timeline below makes this concrete: three research tasks run concurrently, and you choose which of their outputs feed the writer’s context. Because the writer waits for all of its context tasks, it starts only once its slowest selected input finishes—so dropping that input lets the whole crew finish sooner:

Expand Agent Capabilities With Tools

Right now, your agents can only generate text based on their training data. But what if an agent needs current information or needs to interact with external systems? That’s where tools come in. Tools are functions that agents can call to expand their capabilities beyond text generation.

You’ll use the ScrapeWebsiteTool to give your researcher the ability to scrape live data from a website. This is particularly useful for facts tied to a specific page, such as the current Python version listed on python.org:

fromcrewaiimport LLM, Agent, Crew, Task
fromcrewai_toolsimport ScrapeWebsiteTool

llm = LLM(model="gemini/gemini-2.5-pro")

scrape_tool = ScrapeWebsiteTool()

researcher = Agent(
    role="Python Release Analyst",
    goal="Find the latest Python release information",
    backstory=(
        "You're a developer advocate who tracks Python releases"
        " and summarizes what's new for the community."
    ),
    tools=[scrape_tool],
    llm=llm,
)

writer = Agent(
    role="Tech Blogger",
    goal="Write concise release summaries for a developer audience",
    backstory=(
        "You write clear, engaging blog posts that help developers"
        " stay up to date with the Python ecosystem."
    ),
    llm=llm,
)

research_task = Task(
    description=(
        "Scrape https://www.python.org/downloads/ and report"
        " the latest stable Python version number and its release date"
    ),
    expected_output="The latest Python version number and release date",
    agent=researcher,
)

writing_task = Task(
    description=(
        "Write a one-paragraph announcement based on the Python"
        " release information provided by the research task"
    ),
    expected_output=(
        "A concise one-hundred-word announcement covering the"
        " latest Python version number and release date"
    ),
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Notice that only the researcher has scrape_tool in its tools list. The writer doesn’t need web access because it works with the research output it receives through the context parameter.

This pattern of giving different agents different tools mirrors how real teams work. Your researcher has access to databases and search engines. Your writer has access to style guides and templates. Each specialist has the tools they need, and no more.

You can also override an agent’s tools at the task level by passing tools=[...] to a specific Task. This lets the same agent use different tools for different assignments, which can be useful for complex workflows.

Beware of Limitations and Gotchas

CrewAI makes multi-agent coordination feel clean and intuitive. However, there are some important constraints you should understand before building production systems. Being aware of these trade-offs early will help you make better architectural decisions, avoid surprising failure modes in production, and save significant debugging time later.

Conclusion

You’ve set up CrewAI and built your first multi-agent team, chaining specialized agents into a sequential workflow. You also weighed the practical trade-offs of running agent crews in production.

CrewAI excels at structured, role-based workflows where each agent has clear responsibilities. It saves you from complex orchestration code by handling task coordination and data flow automatically.

In this tutorial, you’ve learned how to:

• Install and configure CrewAI with an LLM provider and API key
• Create specialized agents with roles, goals, and backstories
• Build coordinated teams that pass outputs between tasks automatically
• Control task dependencies explicitly using the context parameter
• Equip agents with tools to expand their capabilities beyond text generation
• Weigh the trade-offs in API costs, execution patterns, and communication styles

With these skills, you can start building AI agent teams that coordinate complex workflows, each agent focusing on what it does best.

Next Steps

Now that you understand the core features of CrewAI, you can explore more advanced topics:

• Experiment with hierarchical coordination: Try Process.hierarchical with a manager_llm to see how a manager agent delegates work to team members dynamically.
• Create custom tools: Use the @tool decorator from crewai.tools to build your own tools that agents can invoke.
• Explore advanced features: Check out the CrewAI documentation for Memory, Knowledge, and Flows.
• Compare with other frameworks: If you’re choosing between frameworks, explore LangGraph for state machine control or AG2 for conversational patterns.

You can also start building practical projects like content generation pipelines, research automation systems, or customer service agents. CrewAI’s role-based architecture helps you ship reliable multi-agent applications with minimal boilerplate.

For a guided path through these topics, Real Python’s LLM Application Development With Python learning path organizes tutorials and video courses on working with language models, so you can deepen your skills with a structured curriculum.

Frequently Asked Questions

Now that you have some experience with CrewAI in Python, you can use the questions and answers below to check your understanding and recap what you’ve learned.