# CrewAI: features, protocols, quickstart

## 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

| Field | Value |
| --- | --- |
| Type | Framework |
| Languages / SDKs | Python |
| License | MIT |
| Pricing model | [Open core](https://crewai.com/pricing) |
| 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](https://github.com/crewAIInc/crewAI) |
| Website | [crewai.com](https://crewai.com) |
| Documentation | [docs.crewai.com](https://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](https://docs.crewai.com/en/concepts/agents))
- Two crew processes: sequential task order, or hierarchical, where a manager LLM or agent assigns and reviews tasks. ([source](https://docs.crewai.com/en/concepts/processes))
- Flows: event-driven workflows built with `@start`, `@listen` and `@router` methods over shared, optionally persisted state. ([source](https://docs.crewai.com/en/concepts/flows))
- A single `Memory` class that uses an LLM to tag what it stores and ranks recall by semantic match, recency and importance. ([source](https://docs.crewai.com/en/concepts/memory))
- Checkpointing saves execution snapshots so a crew, flow or agent can resume after a failure or be forked. ([source](https://docs.crewai.com/en/concepts/checkpointing))
- MCP servers attach to an agent through the `mcps` field, over stdio, SSE or Streamable HTTP. ([source](https://docs.crewai.com/en/mcp/overview))
- A2A support in both directions: agents can delegate to remote A2A agents or be exposed as A2A servers (`crewai[a2a]` extra). ([source](https://docs.crewai.com/en/learn/a2a-agent-delegation))
- `@human_feedback` decorator that pauses a Flow for review and routes on the outcome (CrewAI 1.8.0+). ([source](https://docs.crewai.com/en/learn/human-feedback-in-flows))

## 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

| Protocol | Support | Evidence | Note |
| --- | --- | --- | --- |
| MCP | Yes (checked 2026-09-30) | [link](https://docs.crewai.com/en/mcp/overview) | Client: agents consume MCP server tools via the `mcps` field (stdio, SSE, Streamable HTTP) or `MCPServerAdapter` from `crewai-tools`. |
| A2A | Yes (checked 2026-09-30) | [link](https://docs.crewai.com/en/learn/a2a-agent-delegation) | 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 (checked 2026-09-30) | [link](https://docs.crewai.com/en/guides/frontend/overview) | 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](https://multiagentguide.top/best/research-agents.md))
- Business workflows that need approval gates and routing on reviewer feedback ([shortlist](https://multiagentguide.top/best/enterprise-governance.md))
- 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

```sh
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.).

```python
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: https://docs.crewai.com/en/installation

## Pros

- The role, goal and backstory model keeps multi-agent setups readable, and new projects are scaffolded as JSON config. ([source](https://github.com/crewAIInc/crewAI/blob/main/README.md))
- Crews for autonomy and Flows for explicit control ship in the same package and can call each other. ([source](https://docs.crewai.com/en/concepts/flows))
- First-party A2A in both directions, alongside a native MCP client. ([source](https://docs.crewai.com/en/learn/a2a-agent-delegation))
- Checkpointing lets a failed crew or flow resume instead of starting over. ([source](https://docs.crewai.com/en/concepts/checkpointing))
- Human review can route a Flow to different branches based on the reviewer's verdict. ([source](https://docs.crewai.com/en/learn/human-feedback-in-flows))

## Cons

- Anonymous telemetry is enabled by default and must be switched off with `OTEL_SDK_DISABLED=true`. ([source](https://github.com/crewAIInc/crewAI/blob/main/README.md))
- Supported Python range stops below 3.14 (`>=3.10, <3.14`). ([source](https://docs.crewai.com/en/installation))
- Webhook-based human input for production deployments is documented as an Enterprise (AMP) feature. ([source](https://docs.crewai.com/en/learn/human-in-the-loop))
- `A2AConfig` is deprecated and scheduled for removal in v2.0.0, so early A2A code needs rewriting. ([source](https://docs.crewai.com/en/learn/a2a-agent-delegation))
- `@human_feedback` blocks on console input by default; non-blocking review needs a custom provider. ([source](https://docs.crewai.com/en/learn/human-feedback-in-flows))

## Alternatives

- [Agno](https://multiagentguide.top/tools/agno.md) ([CrewAI vs Agno](https://multiagentguide.top/compare/crewai-vs-agno.md))
- [AutoGen](https://multiagentguide.top/tools/autogen.md)
- [LangGraph](https://multiagentguide.top/tools/langgraph.md) ([CrewAI vs LangGraph](https://multiagentguide.top/compare/langgraph-vs-crewai.md))
- [Microsoft Agent Framework](https://multiagentguide.top/tools/microsoft-agent-framework.md)
- [OpenAI Agents SDK (Python)](https://multiagentguide.top/tools/openai-agents-sdk.md)

## 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

- [CrewAI GitHub repository](https://github.com/crewAIInc/crewAI)
- [CrewAI documentation](https://docs.crewai.com/)
- [CrewAI README](https://github.com/crewAIInc/crewAI/blob/main/README.md)
- [CrewAI homepage](https://crewai.com)
- [Installation (CrewAI docs)](https://docs.crewai.com/en/installation)
- [Quickstart (CrewAI docs)](https://docs.crewai.com/en/quickstart)
- [Agents (CrewAI docs)](https://docs.crewai.com/en/concepts/agents)
- [Processes (CrewAI docs)](https://docs.crewai.com/en/concepts/processes)
- [Flows (CrewAI docs)](https://docs.crewai.com/en/concepts/flows)
- [Memory (CrewAI docs)](https://docs.crewai.com/en/concepts/memory)
- [Checkpointing (CrewAI docs)](https://docs.crewai.com/en/concepts/checkpointing)
- [MCP Servers as Tools in CrewAI](https://docs.crewai.com/en/mcp/overview)
- [Agent-to-Agent (A2A) Protocol (CrewAI docs)](https://docs.crewai.com/en/learn/a2a-agent-delegation)
- [Human Feedback in Flows (CrewAI docs)](https://docs.crewai.com/en/learn/human-feedback-in-flows)
- [Human Input on Execution (CrewAI docs)](https://docs.crewai.com/en/learn/human-input-on-execution)
- [Human-in-the-Loop Workflows (CrewAI docs)](https://docs.crewai.com/en/learn/human-in-the-loop)
- [Frontend Overview: CopilotKit and AG-UI (CrewAI docs)](https://docs.crewai.com/en/guides/frontend/overview)
- [AG-UI README, supported integrations](https://github.com/ag-ui-protocol/ag-ui/blob/main/README.md)
- [CrewAI pricing](https://crewai.com/pricing)
- [Skills for coding agents (CrewAI docs)](https://docs.crewai.com/en/skills)

Corrections or removal requests: support@multiagentguide.top

---

Data as of 2026-10-01. Not affiliated with listed projects. HTML version: https://multiagentguide.top/tools/crewai