CrewAI

By CrewAI

Role-based multi-agent orchestration — assemble a crew of agents with goals and tasks.

Website ↗ Repository ↗ Docs ↗

v1.15.52026-07-20PythonMIT

#multi-agent #orchestration #crew #python

56.0k Open source Free tier Paid

Doc version 1.0 · Updated June 28, 2026

Related concepts

Harness Engineering Doc version 1.0 · Updated June 28, 2026 Wrapping an LLM in scaffolding — a control loop, tools, a sandbox, guardrails, and evaluation — so it behaves reliably in production.

Related tools

LangGraph

Multi-Agent Orchestration

LiteLLM

Gateways & Routers

Overview

CrewAI assembles a crew of role-specialized agents that collaborate on tasks toward a goal.
Each agent has a role, goal, and backstory; you hand the crew a list of tasks and kickoff runs them — sequentially or in parallel.

flowchart LR
  agents[agents] --> crew[Crew]
  tasks[tasks] --> crew
  crew --> out[result]

The Code samples tab shows a single agent and a multi-agent sequence — pick from the selector to compare.

When to use it

Choose CrewAI when the work splits naturally across roles (researcher, writer, reviewer) and you want a high-level way to wire their collaboration.

Pricing

Open-source framework, free to self-host. The CrewAI AMP cloud adds managed runs and orchestration.

Plan	Price	Notes
Free	$0	50 runs/mo, community support
Pro	$25/mo	100 runs included, then $0.50/run
Enterprise	Custom	SSO, dedicated support, on-prem options

Source ↗ · as of 2026-06-27

Example

Python · one agent

When to use

Reach for CrewAI when you want role-specialized agents collaborating on tasks toward a goal.

How it flows

You declare agents (role/goal) and tasks, group them in a Crew, and kickoff runs the tasks.

Structure

flowchart LR
  agents[agents] --> crew[Crew]
  tasks[tasks] --> crew
  crew --> out[result]

from crewai import Agent, Task, Crew

# llm is a provider/model string; CrewAI uses native providers (crewai[anthropic]).
researcher = Agent(
    role="Researcher",
    goal="Explain tools clearly and briefly",
    backstory="A concise technical writer.",
    llm="anthropic/claude-opus-4-8",
)

task = Task(
    description="Summarize what CrewAI does in one sentence.",
    expected_output="a single sentence",
    agent=researcher,
)

crew = Crew(agents=[researcher], tasks=[task])
print(crew.kickoff())

When to use

Use several agents in sequence when one hands work to the next (research then write).

How it flows

A sequential process runs each task in order, passing context from one agent to the next.

Structure

flowchart LR
  r[Researcher] --> w[Writer]
  w --> out[tweet]

from crewai import Agent, Task, Crew, Process

researcher = Agent(role="Researcher", goal="Find key facts",
                   backstory="Thorough.", llm="openai/gpt-4o")
writer = Agent(role="Writer", goal="Write a tweet",
               backstory="Punchy.", llm="openai/gpt-4o")

facts = Task(description="List 3 facts about vector databases.",
             expected_output="3 bullets", agent=researcher)
tweet = Task(description="Turn the facts into one tweet.",
             expected_output="a tweet", agent=writer)

crew = Crew(agents=[researcher, writer], tasks=[facts, tweet],
            process=Process.sequential)
print(crew.kickoff())

Example

CrewAI — a one-agent crew

A real, runnable mini-project. Download it and run with Docker.

View samples/crewai_1 on GitHub ↗

June 28, 2026

CrewAI — a one-agent crew

A tiny CrewAI script: it defines an agent (role + goal) and a task, groups them in a Crew, and runs kickoff.

Configure

cd samples/crewai_1
cp .env.sample .env
# edit .env: set ANTHROPIC_API_KEY

CrewAI 1.x uses native model providers, so this sample installs crewai[anthropic] and defaults to anthropic/claude-opus-4-8. To use another provider, add its extra (e.g. crewai[openai]) and change MODEL. .env is gitignored — only .env.sample is committed.

Run with Docker

cd samples/crewai_1
docker build -t aas-crewai .
docker run --rm --env-file .env aas-crewai "CrewAI"

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the foreground docker run above often prints nothing and exits 0 — but the run itself succeeds. The script runs to completion and Docker captures all of its output; only the live attached stream drops it over the VM boundary. Run detached and follow the logs instead:

cd samples/crewai_1
docker build -t aas-crewai .
docker logs -f "$(docker run -d --env-file .env aas-crewai "CrewAI")"

Run locally

cd samples/crewai_1
pip install -r requirements.txt
python app.py "CrewAI"

python-dotenv loads .env automatically.

Example run

Output varies by model and run — LLMs are non-deterministic, so the wording differs each time. Below is one run with anthropic/claude-opus-4-8.

CrewAI is an open-source framework for orchestrating multiple AI agents that
collaborate as a coordinated team to automate complex tasks.

Files

.env.sample

# Copy this file to `.env` and add your Anthropic API key.
#   cp .env.sample .env
#
# CrewAI 1.x uses native model providers (not LiteLLM), so this sample installs
# crewai[anthropic] and defaults to Claude. To use another provider, add its
# extra (e.g. crewai[openai]) and change MODEL.
MODEL=anthropic/claude-opus-4-8
ANTHROPIC_API_KEY=

app.py

"""CrewAI: a one-agent crew that runs a task.

Defines an agent (role + goal) and a task, groups them in a Crew, and kicks it
off. The agent's `llm` is a LiteLLM-style string, so MODEL in `.env` picks the
provider without touching the code.

Run:
    docker build -t aas-crewai .
    docker run --rm --env-file .env aas-crewai "CrewAI"
"""

import os
import sys

from crewai import Agent, Crew, Task
from dotenv import load_dotenv

# Load .env when running locally; in Docker the keys come from --env-file.
load_dotenv()

MODEL = os.environ.get("MODEL", "anthropic/claude-opus-4-8")


def main() -> None:
    topic = " ".join(sys.argv[1:]) or "CrewAI"

    writer = Agent(
        role="Technical writer",
        goal="Explain tools clearly and briefly",
        backstory="You write concise one-sentence summaries.",
        llm=MODEL,
    )
    task = Task(
        description=f"Summarize what {topic} does in one sentence.",
        expected_output="a single sentence",
        agent=writer,
    )

    crew = Crew(agents=[writer], tasks=[task])
    print(crew.kickoff())


if __name__ == "__main__":
    main()

Dockerfile

# Image for the CrewAI sample. CrewAI pulls a large dependency set (litellm,
# chromadb, ...), so the first build is slow.
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1
# CrewAI sends anonymous telemetry by default; opt out for a clean, offline run.
ENV CREWAI_DISABLE_TELEMETRY=true
ENV OTEL_SDK_DISABLED=true

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

# Provide your config at run time (.env is NOT baked into the image):
#   docker run --rm --env-file .env aas-crewai "<topic>"
ENTRYPOINT ["python", "app.py"]