CrewAI

Framework · Last verified 2026-09-30 · Install verified 2026-09-30

TL;DR

CrewAI is an MIT-licensed Python framework from crewAI, Inc. for teams of role-based agents. Crews assign tasks to agents with roles and goals, run sequentially or under a manager agent, and Flows add event-driven control and state. It suits Python developers who think in roles and tasks; CrewAI AMP is the paid platform.

Key facts

CrewAI key facts. Data as of 2026-10-01.
Type Framework
Languages / SDKs Python
License MIT
Pricing model Open core
Orchestration pattern Crew / roles
GitHub stars 59,239 (as of 2026-10-01)
GitHub forks 8,618
Last push 2026-10-01
Latest release 1.15.23
Repository crewAIInc/crewAI
Website crewai.com
Documentation docs.crewai.com
Last verified 2026-09-30

Key features

  • Agents are defined by role, goal and backstory, plus tools, an LLM, memory and an optional permission to delegate. (source)
  • Two crew processes: sequential task order, or hierarchical, where a manager LLM or agent assigns and reviews tasks. (source)
  • Flows: event-driven workflows built with @start, @listen and @router methods over shared, optionally persisted state. (source)
  • A single Memory class that uses an LLM to tag what it stores and ranks recall by semantic match, recency and importance. (source)
  • Checkpointing saves execution snapshots so a crew, flow or agent can resume after a failure or be forked. (source)
  • MCP servers attach to an agent through the mcps field, over stdio, SSE or Streamable HTTP. (source)
  • A2A support in both directions: agents can delegate to remote A2A agents or be exposed as A2A servers (crewai[a2a] extra). (source)
  • @human_feedback decorator that pauses a Flow for review and routes on the outcome (CrewAI 1.8.0+). (source)

Architecture and orchestration pattern

Pattern: Crew / roles

CrewAI has two orchestration layers. A Crew is a set of agents, each described by a role, goal and backstory, and a list of tasks. The crew's process decides who does what: sequential runs tasks in list order and passes earlier outputs as context, while hierarchical adds a manager (an LLM or a custom agent) that allocates tasks, checks results and decides when the work is done. Agents may also be allowed to delegate to one another.

A Flow is the deterministic layer: a class whose methods are wired with @start, @listen and @router decorators, sharing a typed or unstructured state object. Flows can call crews, single agents or plain Python, and the docs recommend them as the structure for production apps.

State and memory: Flow state can be persisted and restored, checkpointing records execution snapshots for resume and fork, and the unified Memory class stores facts that crews, agents or flows can recall later. New projects from crewai create crew are JSON-first (agents/*.jsonc, crew.jsonc); a --classic flag keeps the older Python/YAML layout.

Human in the loop

Three documented mechanisms. (1) Setting human_input=True on a task makes the agent ask the user for input in the console before it returns its final answer. (2) In Flows, the @human_feedback decorator (CrewAI 1.8.0+) pauses after a method, shows the output for review, and can map free-text feedback to outcomes such as approved or rejected that route to different listeners; it blocks on console input by default, and a custom HumanFeedbackProvider makes it non-blocking (for example a webhook or Slack callback). (3) Webhook-based human input with a resume API is documented for the Enterprise (AMP) platform. The AG-UI frontend guides also show pausing a run for a user decision in a CopilotKit UI.

Protocols

MCP, A2A and AG-UI support for CrewAI. See the full matrix.
ProtocolSupportNote
MCP Yes evidence
checked 2026-09-30
Client: agents consume MCP server tools via the mcps field (stdio, SSE, Streamable HTTP) or MCPServerAdapter from crewai-tools.
A2A Yes evidence
checked 2026-09-30
Client and server: A2AClientConfig delegates to remote A2A agents and A2AServerConfig exposes an agent as an A2A server; needs the crewai[a2a] extra.
AG-UI Partial evidence
checked 2026-09-30
CrewAI docs show serving a Crew or Flow over AG-UI with the ag-ui-crewai FastAPI package, which is maintained in the AG-UI repository; the AG-UI README lists CrewAI under partnerships.

Best for

  • Research and report pipelines split across specialist agents with clear roles (shortlist)
  • Business workflows that need approval gates and routing on reviewer feedback (shortlist)
  • Python teams that want roles, tasks and processes as ready-made abstractions
  • Mixing autonomous crews with deterministic, stateful Flow steps in one codebase

Not for

  • Python 3.14 or newer environments; the package currently requires Python >=3.10 and <3.14
  • Non-Python stacks; the framework is Python only
  • Teams that need webhook-driven human approval without the paid AMP platform, unless they build a custom feedback provider

Quickstart

uv tool install crewai

Install verified 2026-09-30 (uv 0.11.7, Python 3.12.13, macOS arm64: official uv tool install crewai run with the uv tool directories pointed at a temp folder (nothing installed at user level); crewai --version reports 1.15.23 and from crewai import Agent, Crew, Task ok. Packages came from the mirrors.aliyun.com mirror, so the version is the one that mirror served on this date. Install and import check only; not a functional test.). What this means

from crewai import Agent, Task, Crew, Process

researcher = Agent(role="Researcher", goal="Collect facts about {topic}",
                   backstory="You check primary sources.", llm="gpt-4o-mini")
writer = Agent(role="Writer", goal="Turn notes into a short brief",
               backstory="You write plain summaries.", llm="gpt-4o-mini")

notes = Task(description="List five facts about {topic}.",
             expected_output="Five bullet points", agent=researcher)
brief = Task(description="Write a 100-word brief from the notes.",
             expected_output="One paragraph", agent=writer,
             context=[notes], human_input=True)  # asks you before finishing

crew = Crew(agents=[researcher, writer], tasks=[notes, brief],
            process=Process.sequential)
result = crew.kickoff(inputs={"topic": "the A2A protocol"})
print(result.raw)

Common pitfalls

  • Requires Python >=3.10 and <3.14.
  • uv tool install crewai installs the CLI; inside a project use crewai install or add crewai to the project environment, since upgrading the CLI does not upgrade a project's pinned version.
  • On Windows, a chroma-hnswlib build error means Visual Studio Build Tools (C++ workload) are missing.
  • Agents default to OpenAI models, so OPENAI_API_KEY must be set unless another LLM is configured.
  • crewai create crew now generates a JSON-first project; pass --classic for the older crew.py + YAML layout.
  • Anonymous telemetry is on by default; set OTEL_SDK_DISABLED=true to turn it off.

Official quickstart

Pros

  • The role, goal and backstory model keeps multi-agent setups readable, and new projects are scaffolded as JSON config. (source)
  • Crews for autonomy and Flows for explicit control ship in the same package and can call each other. (source)
  • First-party A2A in both directions, alongside a native MCP client. (source)
  • Checkpointing lets a failed crew or flow resume instead of starting over. (source)
  • Human review can route a Flow to different branches based on the reviewer's verdict. (source)

Cons

  • Anonymous telemetry is enabled by default and must be switched off with OTEL_SDK_DISABLED=true. (source)
  • Supported Python range stops below 3.14 (>=3.10, <3.14). (source)
  • Webhook-based human input for production deployments is documented as an Enterprise (AMP) feature. (source)
  • A2AConfig is deprecated and scheduled for removal in v2.0.0, so early A2A code needs rewriting. (source)
  • @human_feedback blocks on console input by default; non-blocking review needs a custom provider. (source)

Alternatives

All CrewAI alternatives

FAQ

Does CrewAI support MCP?

Yes, as a client. Agents can load tools from MCP servers through the mcps field or MCPServerAdapter, over stdio, SSE or Streamable HTTP.

Does CrewAI support A2A?

Yes. With the crewai[a2a] extra, an agent can delegate to remote A2A agents (A2AClientConfig) or be exposed as an A2A server (A2AServerConfig).

Is CrewAI free?

The framework is MIT-licensed. crewAI, Inc. also sells CrewAI AMP; its pricing page lists a free Basic tier and a custom-priced Enterprise plan.

Does CrewAI work with Claude Code or Codex?

CrewAI publishes an official skills pack (crewaiinc/skills, also a Claude Code plugin) that teaches coding agents such as Claude Code and Codex how to write CrewAI projects. It is guidance for the coding agent, not a runtime integration.

What is the difference between a Crew and a Flow?

A Crew lets role-based agents work through tasks, sequentially or under a manager. A Flow is an event-driven class with explicit steps and shared state that can call crews.

Sources

Something wrong or out of date, or do you maintain CrewAI and want this page removed? Report a correction or request removal.