What it is: CrewAI is an open-source Python framework for building multi-agent systems. Instead of asking one model to do a whole complex job, you define several agents — each with a role, a goal, and a backstory — hand them tasks, and let a crew coordinate the hand-offs. It's MIT-licensed and standalone: its own primitives for agents, tasks, crews, flows, and tools, not a layer on top of LangChain.
Who it's for: Builders whose problem splits naturally into roles — a researcher that gathers, a writer that drafts, a reviewer that checks — and who want the coordination plumbing handled instead of hand-writing the glue between model calls.
The idea: roles, not one giant prompt#
A single agent with a 2,000-word system prompt trying to research, write, and fact-check at once is hard to steer and harder to debug. CrewAI's bet is that the same job is easier to build and reason about as a team: give each agent one clear job and a defined output, and let the framework route work between them. You write the what — who's on the crew and what each is responsible for — and CrewAI handles the how of passing work along.
How you use it — a crew in a few lines#
pip install crewaifrom crewai import Agent, Task, Crew
researcher = Agent(
role="Researcher",
goal="Find and verify the latest on {topic}",
backstory="A meticulous analyst who never states a fact without a source.",
)
writer = Agent(
role="Writer",
goal="Turn the research into a tight 5-bullet brief",
backstory="An editor who writes for busy founders and cuts every wasted word.",
)
research = Task(
description="Research {topic}. Return verified facts with sources.",
expected_output="A list of verified facts, each with a source URL.",
agent=researcher,
)
brief = Task(
description="Write a 5-bullet brief from the research.",
expected_output="Five skimmable bullets, each citing a source.",
agent=writer,
)
crew = Crew(agents=[researcher, writer], tasks=[research, brief])
result = crew.kickoff(inputs={"topic": "agent memory"})
print(result)The shape is: define agents, give them tasks, assemble a Crew, call kickoff(). The researcher's output feeds the writer's task; you didn't write that hand-off, the crew did.
One agent with a giant prompt is a monolith. A crew of small, role-scoped agents is a team you can debug one member at a time.
Crews vs. Flows — the one distinction to learn#
CrewAI gives you two orchestration modes, and picking the right one is most of the design work:
- Crews are autonomous: agents collaborate and decide how to pass work off. Use them for open-ended tasks where you want flexible, dynamic interaction.
- Flows are event-driven and deterministic: you control the exact execution path and manage state explicitly. Use them for pipelines that must run the same way every time.
They compose — a Flow can call a Crew — so the common production pattern is a deterministic outer Flow wrapping the autonomous Crew steps. If you're weighing CrewAI against the alternatives, the Crews-vs-Flows breakdown and the framework comparisons go deeper on when each shape wins.
Free core, paid production layer#
The framework is MIT-licensed and free to self-host — pip install and go. For teams shipping to production, CrewAI sells the AMP suite: a managed Control Plane (app.crewai.com) that adds deployment, observability, governance, and enterprise support. You can build and run entirely on the open-source core; AMP is the "don't operate the orchestration yourself" option.
The one-line take#
If your task decomposes into roles and you want the hand-offs handled for you, CrewAI turns "one model doing everything" into a small crew you assemble in a few lines — autonomous Crews when you want flexibility, deterministic Flows when you want control.
