CrewAI
Last reviewed
May 24, 2026
Sources
No citations yet
Review status
Needs citations
Revision
v1 · 3,331 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
May 24, 2026
Sources
No citations yet
Review status
Needs citations
Revision
v1 · 3,331 words
Add missing citations, update stale details, or suggest a clearer explanation.
CrewAI is an open-source Python framework for orchestrating role-playing, autonomous AI agents that collaborate as a "crew" to complete complex tasks.[^1] The framework was created by Brazilian software engineer João Moura in October 2023 and released on GitHub in November 2023, with the first PyPI package (crewai 0.1.0) shipping on November 14, 2023.[^2][^3] CrewAI defines a small set of primitives, Agent, Task, Crew, Process, and Flow, that let developers assemble teams of llms-powered workers with explicit roles, goals, and backstories who delegate work to one another.[^4] Originally written on top of langchain, the framework was rewritten in 2024 to be fully independent, with LLM access routed through litellm so the same crew can run against openai, anthropic, Google, AWS Bedrock, or local models served via ollama.[^5][^6] By the v1.0 general availability release on October 20, 2025 CrewAI had crossed 40,000 GitHub stars, 1.8 million monthly downloads, and was reportedly used by 60% of Fortune 500 companies.[^7]
João Moura is a Brazilian software engineer based in São Paulo who began his career writing Ruby and Elixir before moving into machine learning.[^8] Before founding CrewAI he was Director of AI Engineering at the marketing data company Clearbit, where he led a small team building llms-powered automations for content production and lead generation.[^9] Clearbit was acquired by HubSpot in November 2023.[^10] Moura has described the period leading up to the acquisition as one in which he was repeatedly rebuilding ad-hoc orchestration code to chain multiple LLM calls together, and he wanted a reusable abstraction for "groups of agents that work together like a small team."[^11]
The first prototype that became CrewAI was an internal Clearbit project that automated outbound content creation and LinkedIn posting; according to Insight Partners' write-up of the company, that system was generating up to 600 daily inbound leads at peak.[^12] Moura completed the standalone, open-sourceable version of the framework in October 2023 and pushed the first public commits to github.com/joaomdmoura/crewai in November 2023.[^2][^3]
The initial release was modest. Version 0.1.0 was published to PyPI on November 14, 2023, exposing three classes, Agent, Task, and Crew, and a single Process.sequential execution mode.[^3] The framework picked up traction quickly because the API was much smaller than the prevailing langchain agent abstractions of the time; the README example showed a working two-agent "researcher plus writer" system in roughly twenty lines of Python.[^1] Within two months the repository had passed 8,000 stars and Moura was running through pull-request triage in the evenings while still employed at HubSpot.[^9]
In January 2024 the project was incorporated as a Delaware C-corp under the name crewAI, Inc., with Moura as Chief Executive Officer and Rob Bailey, a former AI startup operator, as Chief Operating Officer.[^12] Moura moved the repository to the crewAIInc GitHub organisation, where it lives today as github.com/crewAIInc/crewAI; the old joaomdmoura/crewai URL still resolves via redirect.[^1] An angel and seed round led by Boldstart Ventures closed in the first half of 2024 with participation from Craft Ventures, Earl Grey Capital, and Firsthand Ventures.[^13]
On October 22, 2024 CrewAI announced an $18 million Series A round led by Insight Partners, with continued participation from Boldstart, Craft, Earl Grey, Firsthand, and Blitzscaling Ventures, and angel checks from andrew ng and HubSpot co-founder Dharmesh Shah.[^14][^15] The figure of $18 million covered total funding raised across the inception round and the Series A; specific allocation between the two rounds was not disclosed.[^14] The funding announcement was timed with the launch of CrewAI Enterprise, a hosted control plane that adds tracing, role-based access control, and a managed deployment runtime on top of the open-source library.[^15][^16] TechCrunch reported that CrewAI had signed 150 enterprise customers in the nine months following the January 2024 corporate launch and was processing roughly 100,000 multi-agent executions per day at the time of the announcement.[^17]
Through late 2024 and 2025 the framework went through a substantial architectural overhaul. Three changes stand out. First, CrewAI removed langchain from its required dependencies; the team rewrote the prompt assembly, tool dispatch, and memory layers from scratch around its own LLM class which delegates to litellm.[^5] Second, the November 2024 v0.83.0 release added before_kickoff and after_kickoff callbacks and first-class integration with the Mem0 memory backend.[^4] Third, in early 2025 the team introduced CrewAI Flows, an event-driven workflow layer for chaining multiple crews and deterministic functions together with state persistence.[^18]
Subsequent releases focused on production hardening: asynchronous execution for tasks and tools (v0.130.0, June 2025), Mem0 v2 support and ad-hoc tool calls (v0.150.0, July 2025), Qdrant retrieval-augmented generation and the Agent-to-Agent protocol (v0.175.0, August 2025), and finally v1.0.0 on October 20, 2025, which froze the public API and shipped native tracing, a unified CLI, and first-class model context protocol support.[^4][^7] At the time of GA the project reported 40,000+ GitHub stars and 1.4 billion cumulative agentic executions across all deployments.[^7] The current release on PyPI as of May 2026 is 1.14.5.[^3]
CrewAI is built around four runtime primitives, Agent, Task, Crew, and Process, plus an optional higher-level orchestration layer called Flow. All of the primitives are Pydantic v2 models, so configuration can be loaded from YAML or constructed in code with type checking.[^19]
An Agent is a llms-powered worker with a fixed identity and a toolkit. The three required fields are role (the job title, for example "Senior AI Researcher"), goal (the objective the agent optimises for), and backstory (a few sentences of context that shape the system prompt).[^19] These three strings are concatenated into the agent's system message at runtime.
Additional Agent parameters include:
llm: the language model handle, expressed as a LiteLLM-style provider/model string (for example anthropic/claude-sonnet-4-5 or ollama/llama3.1). If unset the agent defaults to gpt-4o-mini via the OPENAI_MODEL_NAME environment variable.[^6][^19]tools: a list of BaseTool subclasses the agent may invoke. CrewAI ships its own toolkit and can also load langchain tools.[^19]memory: a boolean that turns on conversation memory for the agent.[^20]max_iter: the maximum number of tool-use iterations before the agent must return a final answer (default 20).[^19]max_rpm: requests-per-minute throttle to avoid provider rate limits.[^19]allow_delegation: when true, the agent can hand off subtasks to peers in the same crew.[^19]reasoning and max_reasoning_attempts: enables a "plan-then-execute" cycle in which the agent drafts a plan with chain of thought before any tool call.[^19]multimodal: enables image input on supported models.[^19]A new Agent can also be invoked directly with agent.kickoff("question") without belonging to any crew; the result is a TaskOutput containing the raw text, an optional Pydantic object, and a JSON dictionary.[^19]
A Task is a unit of work assigned to one agent. Its required fields are description (what to do) and expected_output (what the answer should look like).[^21] Tasks compose through the context parameter, which takes a list of upstream tasks whose outputs become input context for the current task.[^21] Other notable parameters include:
output_pydantic and output_json: force the agent's final response to conform to a Pydantic model or JSON schema.[^21]output_file: write the raw output to disk, automatically creating parent directories.[^21]async_execution: kick off the task in the background; downstream tasks that list it in context automatically wait for completion.[^21]guardrail and guardrails: callable validators that re-prompt the agent if its output fails a check; CrewAI also supports natural-language guardrails where the validation criterion is supplied as a string and a separate LLM call adjudicates.[^21]human_input: pauses the run for a human approval step before the result is finalised.[^21]markdown: instructs the agent to format the answer as Markdown.[^21]A Crew binds together a list of Agent objects, a list of Task objects, and a Process describing how the tasks should be executed.[^22] Calling crew.kickoff(inputs={...}) runs the workflow and returns a CrewOutput. Optional crew-level parameters include memory (turn on cross-task memory for the whole crew), cache (cache tool calls), verbose (log every LLM call), embedder (the embedding model used for memory), manager_llm or manager_agent (required for hierarchical processes), and planning (insert a planning agent that drafts a task plan before each iteration).[^22]
CrewAI exposes three execution modes via the Process enum:
Process.sequential runs tasks in declaration order. Each task receives the previous task's output as additional context unless context is set explicitly. This is the default and the mode covered in most tutorials.[^23]Process.hierarchical introduces a manager agent that does not perform tasks itself; instead it inspects the task list at runtime, decides which agent should handle each task, dispatches the work, and validates the output. A manager_llm or a fully specified manager_agent must be provided.[^23]Process.consensual is reserved in the codebase but the documentation notes it is not implemented as of v1.x; it is intended for democratic decision-making among peer agents.[^23]CrewAI Flows are a higher-level orchestration layer introduced in early 2025 for production workloads.[^18] A Flow is a Python class whose methods are decorated to express an event-driven graph:
@start() marks an entry point. Multiple @start methods run in parallel.@listen(other_method) marks a step that runs after another step emits an output.@router(condition_fn) dispatches to one of several downstream branches.Flow state can be either an unstructured Python dictionary (good for prototypes) or a typed Pydantic model (the default for production). Each flow run is assigned a UUID and the framework can persist state between steps, so a long-running flow can be resumed if a process restarts.[^18] Crews and Flows interoperate: a flow step can call crew.kickoff() to delegate an entire sub-workflow to a crew, and many production deployments use flows as the outer orchestration with crews as inner stages.[^18]
The official crewai-tools package contains around fifty pre-built tools.[^24] Categories include:
SerperDevTool (Serper.dev), BraveSearchTool, EXASearchTool, TavilySearchTool.[^25]ScrapeWebsiteTool, FirecrawlScrapeWebsiteTool, BrowserbaseLoadTool.[^25]FileReadTool, DirectoryReadTool, FileWriterTool, PDFSearchTool, CSVSearchTool, DOCXSearchTool.[^24]MongoDBVectorSearchTool, QdrantVectorSearchTool, WeaviateVectorSearchTool, PGSearchTool.[^24]CodeInterpreterTool (runs code in a sandboxed Docker container).[^24]SerperScrapeNewsTool, YoutubeChannelSearchTool, GitHubSearchTool, plus Composio-backed integrations to Gmail, Slack, Salesforce, HubSpot, and Notion.[^24]Developers can write custom tools by subclassing BaseTool and providing a name, description, and _run method. Because CrewAI implements its own tool calling, custom tools written for langchain can be imported via a small adapter.[^24]
CrewAI originally exposed four discrete memory backends, short-term, long-term, entity, and user memory, each with its own storage path under ./.crewai/memory/.[^20] In v1.x these were consolidated into a single Memory class that uses LiteLLM-driven importance scoring and a tree-structured scope (for example /project/alpha or /agent/researcher) to organise records.[^26] Retrieval ranks candidates by a composite of semantic similarity (default weight 0.5), recency (0.3), and importance (0.2).[^26] Storage is backed by LanceDB by default; alternative backends include ChromaDB and Mem0.[^26] Crews can also pre-seed agent knowledge with the knowledge_sources parameter, which loads PDF, text, JSON, or CSV files into a retrieval augmented generation rag index attached to the agent.[^19]
CrewAI delegates all LLM calls to litellm, the BerriAI gateway library that exposes 100+ providers behind an OpenAI-compatible interface.[^6] Inside a Crew, every agent uses the model string passed in its llm field. The string follows LiteLLM's provider/model convention. Worked examples from the official documentation include:[^6]
| Provider | Example model string |
|---|---|
| openai | gpt-4o, gpt-4o-mini, o3-mini |
| anthropic | anthropic/claude-sonnet-4-5, anthropic/claude-haiku-4-5 |
gemini/gemini-2.5-pro | |
| Azure OpenAI | azure/gpt-4o |
| AWS Bedrock | bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0 |
| Cohere | command-r-plus |
| Local via ollama | ollama/llama3.1, ollama/qwen2.5:7b |
| Groq | groq/llama-3.3-70b-versatile |
| HuggingFace TGI | huggingface/meta-llama/Meta-Llama-3-70B-Instruct |
In v1.0 the team began promoting "native" SDK integrations for OpenAI, Anthropic, Google Gemini, Azure, and Bedrock that bypass LiteLLM and call the provider's SDK directly, which gives access to provider-specific features such as Anthropic prompt caching and OpenAI structured outputs.[^6] LiteLLM remains the fallback for every other provider.[^6]
In addition to the open-source library, CrewAI ships a commercial AMP (Agent Management Platform) suite that includes tracing, version control, environment management, and a hosted runtime.[^7][^16] A component of AMP called CrewAI Studio (originally Crew Studio in early 2025) is a browser-based visual builder where users describe a workflow in natural language and the system materialises agents, tasks, and tools onto a drag-and-drop canvas.[^27] Workflows authored in Studio can be exported as a Python project that uses the open-source crewai library, giving non-developers a path into the codebase.[^27] Studio integrates natively with Asana, Gmail, HubSpot, Microsoft Teams, Salesforce, Slack, and Zendesk; private tools can be registered to an organisation-scoped repository.[^27]
A third-party project also called CrewAI-Studio, maintained by GitHub user strnad, is a separate community-built GUI that wraps the open-source library; it is unaffiliated with the commercial AMP product.[^28]
CrewAI competes in a crowded space of agent frameworks that emerged in 2023 and 2024. The table below summarises the main alternatives.
| Framework | First release | Maintainer | Primary abstraction | License |
|---|---|---|---|---|
| CrewAI | November 2023 | crewAI, Inc. | Role-based crews + event-driven flows | MIT |
| langgraph | January 2024 | LangChain Inc. | Stateful graphs (nodes and edges) | MIT |
| autogen | September 2023 | microsoft Research, later AG2 community | Conversable agents in a group chat | CC-BY-4.0 / Apache-2.0 |
| OpenAI Swarm | October 2024 | openai (educational) | Handoffs between agents | MIT |
| openai agents sdk | March 2025 | OpenAI | Productionised handoffs | MIT |
| agno | 2024 | Agno team | Single-agent + multi-agent teams | MPL-2.0 |
Several practical contrasts come up repeatedly in third-party reviews:
By the v1.0 GA milestone, CrewAI reported the following adoption numbers, taken from the company's own announcement and Insight Partners' portfolio writeup:[^7][^12]
learn.crewai.com community courses.[^7]Named enterprise users disclosed in vendor case studies and partner press releases include IBM, microsoft, Procter and Gamble, Walmart, PayPal, SAP, Adobe, PwC, Capgemini, Deloitte, and NVIDIA.[^7][^16] Public reference workflows include IBM's federal eligibility automation, PwC's enterprise GenAI accelerator, and NVIDIA's "agent-native transformation" partnership announced in 2025.[^33]
The project's contributor base is also broad. The crewAIInc/crewAI repository had 7,200 forks and more than 250 contributors by May 2026, with 115 cumulative open-source releases shipped over two years.[^2][^7]
The open-source crewai library is released under the MIT License.[^2] The accompanying crewai-tools package is also MIT.[^24] The CrewAI Enterprise / AMP control plane is a commercial product with separate terms; pricing is per-seat plus a metered per-execution component, available either as a fully managed SaaS or as a single-tenant deployment in the customer's cloud.[^16] The CrewAI Studio visual builder is part of the AMP suite and is not available under an open-source licence.[^27]
The trademark "CrewAI" is owned by crewAI, Inc., and the company maintains a small core team of approximately 35 employees as of mid-2025, with engineering led by Moura and operations led by Rob Bailey.[^12]