CrewAI is the role-based multi-agent framework. Python-first, MIT-licensed, built around a "crew" metaphor — each agent has a role ("Senior Research Analyst"), a goal ("Find the best market opportunities"), and a backstory the LLM uses to colour its output. Tasks are explicit; agents collaborate through sequential or hierarchical processes; CrewAI Flows handle more complex orchestration. 30,000+ stars on GitHub, one of the most-starred agent frameworks in the field. The fastest path from zero to a working multi-agent prototype.
CrewAI is a Python framework for orchestrating multi-agent systems. Founded by João Moura in 2024, the project went from a personal experiment to one of the most-starred agent frameworks on GitHub inside eighteen months — not because it's the most powerful framework, but because the "crew of specialists" metaphor maps cleanly onto how teams actually think about agentic work.
The thesis: agent design should mirror team design. Hire specialists, give each a clear role and goal, decide whether they work in sequence or under a manager, and let them collaborate on tasks. The framework's primitives match this metaphor exactly — Agent(role, goal, backstory) for the team members, Task(description, expected_output, agent) for the work, Crew(agents, tasks, process) for the team, and Process.sequential or Process.hierarchical for the workflow.
That metaphor lowers the cognitive cost of designing multi-agent systems. Where LangGraph asks you to think in terms of nodes and edges and explicit state, CrewAI asks you to think in terms of "who does what." For prototyping, pitching, and a meaningful subset of production work, that's the right level of abstraction. The trade-off: less fine-grained control than LangGraph, less production tooling than ADK or the vendor SDKs, and more reliance on prompt-engineering for complex flows.
The framework is open source under MIT, with commercial offerings as CrewAI Cloud / Enterprise (managed runtime, monitoring, RBAC) for production deployments. Python-first; a TypeScript port exists but the Python ecosystem is materially larger and most documentation, community examples, and tutorials assume Python.
The framework requires every agent to have a role, goal, and backstory field. These get composed into the system prompt. Critics dismiss this as theatre; in practice, structured role prompts genuinely improve output quality on multi-agent collaboration tasks. The role colours what the agent prioritises ("rigorous analyst" vs "creative copywriter"), the goal shapes what success looks like, and the backstory anchors voice and perspective. CrewAI codifies what good prompt engineers were already doing manually.
The minimum viable CrewAI program is roughly fifteen lines of Python. The framework's surface area is deliberately small: Agent + Task + Crew + Process for the basic case; Flows for cases where the basic case doesn't fit.
The minimal CrewAI in Python — a research crew with two agents and two tasks:
# pip install crewai from crewai import Agent, Task, Crew, Process researcher = Agent( role="Senior Research Analyst", goal="Find emerging trends in SA fintech", backstory="You are a rigorous analyst with deep market knowledge.", verbose=True, ) writer = Agent( role="Tech Writer", goal="Turn research into a clear, compelling brief", backstory="You write for technical executives who value precision.", ) research_task = Task( description="Investigate SA fintech trends in 2026.", expected_output="A structured list of 5-7 trends with evidence.", agent=researcher, ) write_task = Task( description="Synthesise into an executive brief.", expected_output="800-word brief, plain language, no jargon.", agent=writer, ) crew = Crew( agents=[researcher, writer], tasks=[research_task, write_task], process=Process.sequential, ) result = crew.kickoff()
Two process types cover most cases:
Process.sequential — tasks run in order; each task's output is available as context to the next. The simplest pattern, used in 80% of CrewAI examples in the wild.Process.hierarchical — you appoint a manager agent (or let CrewAI generate one) that delegates tasks to crew members and synthesises results. Useful when work order isn't fixed and a "decider" agent makes routing calls.Tools attach to agents. Built-in tools cover web search, file IO, code execution, and more; CrewAI tools wrap LangChain tools (CrewaiTool works in both directions). Custom tools are plain Python classes:
from crewai_tools import SerperDevTool, WebsiteSearchTool researcher = Agent( role="Senior Research Analyst", goal="...", backstory="...", tools=[SerperDevTool(), WebsiteSearchTool()], # web + RAG )
CrewAI Flows are the escape hatch when the agent metaphor isn't enough. Released in 2024 as a complement (not a replacement) to Crews, Flows let you express explicit control flow: state, listeners, conditional branches, deterministic steps. A Flow can call multiple Crews, mix LLM-driven steps with deterministic Python, and orchestrate across longer-running workflows. Where Crews answer "who does what?", Flows answer "in what sequence and under what conditions?":
from crewai.flow.flow import Flow, listen, start class ContentPipeline(Flow): @start() def generate_topics(self): return research_crew.kickoff() # a Crew @listen(generate_topics) def write_drafts(self, topics): return writing_crew.kickoff(inputs={"topics": topics}) @listen(write_drafts) def publish(self, drafts): return publish_to_cms(drafts) # deterministic step
Tasks where the work decomposes naturally into specialist roles, the workflow is mostly sequential or hierarchical, and the team needs to ship a working version this week. Research, content generation, marketing campaigns, sales workflows, product analysis. If you can describe the task as "I'd hire a researcher, a writer, and an editor for this," CrewAI is probably the right framework. If you can't, LangGraph or vendor SDKs will fit better.
CrewAI sits in a similar commercial position to LangGraph: the library is fully MIT, the SaaS is the revenue model. Production teams that adopt CrewAI typically use the open-source library for development and graduate to CrewAI Enterprise when they need managed runtime, monitoring, and RBAC.
The MIT-licensed open-source library. Self-host anywhere. Includes crewai-tools for the standard tool set; LangChain tools work via the CrewaiTool adapter.
TypeScript port of the framework. Smaller community than the Python version; useful for Node-only teams but expect to write more glue code than the Python path.
Managed runtime for crews and flows. Hosted execution, monitoring, RBAC, usage analytics. Free tier; paid tiers for production volume. The commercial revenue line that funds the open-source work.
Pre-built tool catalogue (Serper search, file IO, RAG, code execution) plus LangChain interop. Practical access to the largest tool ecosystem in agent-land without committing to LangChain's framework.
CrewAI ships weekly or near-weekly. New features land regularly; minor breaking changes between versions are not unusual. For production use: pin minor versions, watch the changelog, and test before upgrading. The Flow API in particular has evolved quickly — if you're following 2024 tutorials, expect some methods to have changed shape.
CrewAI is the right answer for a specific shape of project. It's not the right answer for every shape. The honest comparison: CrewAI wins on prototyping speed and metaphor clarity; LangGraph wins on explicit control; ADK wins on managed runtime; vendor SDKs win on first-party model alignment.
| Dimension | CrewAI | LangGraph | ADK / vendor SDKs |
|---|---|---|---|
| Mental model | Roles + goals + tasks | Graph nodes + edges + state | Tool-use loop + sub-agents |
| Prototyping speed | Fastest of the three | Higher boilerplate | Middle |
| Control granularity | Lower — relies on prompts | Highest — explicit graph | Middle — implicit per-call |
| Production tooling | CrewAI Enterprise (paid) | LangSmith (paid) | Vendor consoles + OTel |
| Multi-vendor LLMs | Yes (LiteLLM under the hood) | Yes (any model) | Vendor-specific or via LiteLLM |
| Best fit | Role-decomposable workflows, fast prototyping, content / research / marketing | Compliance-heavy, explicit control, audit-driven work | Vendor-native production agents |
| Worst fit | Workflows that don't decompose into roles; tight latency-sensitive loops | Single-shot agents; non-graph thinking teams | Cross-vendor multi-LLM stacks |
CrewAI works well as a sub-agent that a higher-level orchestrator (LangGraph or ADK) calls via A2A. Pattern: LangGraph orchestrator manages the explicit control flow; when it needs "a research crew on this" or "a content team on that", it dispatches to a CrewAI crew over A2A. This gets you LangGraph's auditability for the control plane and CrewAI's ergonomics for the task-decomposed work.
Six patterns that play to the framework's strengths: role-decomposable work, sequential or hierarchical flow, prototyping-to-production speed, content / research / sales workflows where "a team of specialists" matches the actual job description.
CrewAI is opinionated. The opinion is that role-based decomposition is the right model for most agentic work, and the cost is less explicit control than graph-based frameworks give you. That trade is right for some teams and wrong for others.
CrewAI's vendor-agnostic shape and prototyping speed make it well-suited for SA studio work and pilot projects. The framework runs anywhere, calls any LLM via LiteLLM, and produces working multi-agent prototypes in hours rather than weeks. The constraint: as projects scale into production, teams typically either upgrade to CrewAI Enterprise or migrate the orchestration layer to LangGraph for explicit control.
For SA studios pitching multi-agent systems to clients, CrewAI is hard to beat for the demo. The role-based metaphor reads naturally in client meetings ("this crew has a researcher, a writer, and an editor"), the prototype runs in hours, and the working demo opens conversations that abstract slides don't. The pragmatic SA studio path: prototype in CrewAI, ship the pilot, then decide whether to harden in CrewAI Enterprise or migrate to LangGraph based on the client's audit and compliance requirements.
For SA enterprise (banks, insurers, telcos), CrewAI's flexibility on prototyping is genuinely useful but the production picture is mixed. CrewAI Enterprise covers most needs, but for compliance-heavy domains (banking, insurance claims, healthcare) the structural advantage LangGraph has on explicit graph audit can outweigh CrewAI's prototyping speed. Common pattern: CrewAI for internal tooling and content automation; LangGraph or vendor SDKs for customer-facing or compliance-touching agents.
The CrewAI library is free MIT. CrewAI Enterprise / Cloud is USD-billed. For SA teams watching FX, the same patterns apply as the LangGraph leaf: self-host the open-source library to avoid the SaaS bill, or treat CrewAI Enterprise as a strategic line item with annual pricing locked in. The compute cost is from the underlying LLM — tier routing (Haiku / Sonnet / Opus or GPT-4.x / GPT-5 / o-series) inside the crew is the main cost lever, just as in any other framework.
CrewaiTool adapter. A common pattern: ADK orchestrator calling a CrewAI specialist crew.