CrewAI

What it is

CrewAI is an open-source Python framework for multi-agent work, built on a single organising metaphor: give each agent a role, a goal and a bit of backstory, hand the whole crew a list of tasks, and let them pass work along. It is one of the shortest distances between an idea and a running multi-agent system — a few classes, a process choice, and a command to run it.

The metaphor is doing real work in the design. A “researcher” agent and a “writer” agent differ mostly in their instructions and tools, not in any special runtime behaviour, and CrewAI leans into that: role, goal and backstory are prompt fields, and the framework's job is to sequence the calls and shuttle the outputs between them.

How it works

You define agents (role, goal, backstory, the tools they may call) and tasks (a description, an expected output, and which agent owns it). A crew then runs the tasks under a process: sequential, where each task's output feeds the next, or hierarchical, where a manager-style agent delegates and collates. Alongside the crew machinery the project has added a lower-level Flows layer for explicit step-by-step orchestration, which is the escape hatch for anyone who finds the role-play framing too loose.

Because the agents are mostly prompts plus a tool allowlist, the framework works with whatever model provider you configure. There is a CLI for scaffolding projects and a structured way to define crews in configuration rather than code, which is why teams can stand one up in an afternoon.

When it earns its place over a plain loop

When the work genuinely splits into roles with different tools and different instructions. Content pipelines — research, draft, critique — are the classic case, and the role framing helps stakeholders reason about the system without reading code. It also earns its place when the hand-offs themselves are the interesting part: sequential and hierarchical processes make “who talks to whom” explicit in a way a single agent with a long prompt does not.

Over a plain loop, though, the honest gains are organisational, not cognitive. Several role-playing agents do not reason better than one well-prompted agent with the same tools; they add tokens, latency and failure modes. If your tasks do not split cleanly — and the spec card above is explicit that this is the condition — a crew is ceremony around a chain.

Limits

• Roles are prompts. Backstory and persona shape style more than correctness, and they cost tokens on every turn.
• State handling is the weak joint. Passing outputs between agents is easy; making that state durable, replayable and inspectable is on you.
• Multi-agent overhead is real. Three agents on a task one agent could do means three times the calls and more places for a hand-off to lose information.
• It moves fast. The core concepts have been stable, but the surrounding layers have grown quickly; check the docs for what is current in 2026 rather than trusting any write-up, this one included.

Alternatives on this board

• LangGraph — when you want the hand-offs written down as a state machine rather than implied by roles.
• OpenAI Agents SDK — handoffs and guardrails in a smaller, sturdier API.
• Google ADK — code-first multi-agent with deployment targets attached.
• DSPy — if the real problem is prompt quality rather than role division.