# CrewAI vs LangGraph: Role-Based Crews or Low-Level Graphs?

> CrewAI vs LangGraph: role-based crews and Flows versus explicit graphs, how each saves state and retries, the two Studios, and who bills for deployment.

_Source: https://professionalstoolkit.com/articles/crewai-vs-langgraph — The Professional's Toolkit · updated November 2026_

---

Pick CrewAI if you want agents defined by role, goal and backstory that work together as a crew, with Flows wrapped around them for the steps you must control. Pick LangGraph if you want to draw the graph yourself, node by node, with per-node retries, timeouts and time travel. Both frameworks are MIT-licensed and free to run on your own machines. The real split comes at hosting. CrewAI AMP (Agent Management Platform) has a free Basic plan capped at 50 workflow executions a month[1]. Managed LangGraph deployment needs LangSmith Plus, at $39 per seat a month, or the Enterprise plan. Neither choice is wrong. It depends on how much structure you want handed to you.


**50** — Workflow executions a month on CrewAI AMP's free Basic plan, which is also the maximum on Basic.



- **MIT** — License of both frameworks, free to run yourself
- **$39 per seat a month** — LangSmith Plus, the entry plan for deploying on LangSmith Agent Server (Enterprise also qualifies)
- **3** — LangGraph default retry attempts per node, first try included


## Crews of roles against graphs of nodes

CrewAI prescribes an architecture. An agent has a role, a goal, a backstory, tools and an optional model; a task needs a description and an expected output; a crew runs them **sequentially** by default, each output feeding the next, or **hierarchically**, where a manager set through `manager_llm` or `manager_agent` plans, delegates and reviews. Flows add event-driven control on top: `@start` marks entry points, `@listen` reacts to another step's output and `@router` sends the run down a labeled branch, with state kept as a plain dict or a Pydantic model.

LangGraph takes the opposite position on purpose. LangChain describes it as a low-level orchestration framework and runtime for long-running, stateful agents, and says it does not prescribe prompts or agent architecture. You define shared state, nodes and edges, then compile the graph before you invoke or stream it. Execution moves in Pregel-style super-steps, where parallel nodes share one step; reducers decide how each state key merges updates; `Send` fans a node out per item for map-reduce jobs. For a ready-made agent loop, its docs point you to Deep Agents or LangChain agents instead.

In practice, a researcher, writer and reviewer team in CrewAI is a handful of agent definitions. New projects are JSON-first, with agents in `agents/*.jsonc` and the crew in `crew.jsonc`; the older YAML layout needs `--classic`. LangGraph's own quickstart wires a model node, a tool node and a conditional edge that loops between them. That is more code. It is also more control. CrewAI's docs advise a Crew when the path to the answer is open-ended and a Flow when you decide the steps, order and conditions, which is why our [guide to CrewAI Flows](/articles/crewai-flows) is the closer match for anyone arriving from graphs.


> 💡 **Start from a Flow:** CrewAI's docs advise starting production apps with a Flow and running a Crew inside a step, which feels closest to a graph.


## Saving state, surviving failures, pausing for a human

### Where state lives between runs

In CrewAI, `@persist` saves Flow state to a local SQLite database by default, and you can plug in your own backend. Checkpointing, added in April 2026, snapshots a crew, flow or agent, by default after every finished task, as JSON files or SQLite, so a run can resume after a failure or be forked into a new branch; `crewai checkpoint` opens a terminal UI to browse, resume and fork. Task replay is narrower: it works only from the latest kickoff.

LangGraph splits persistence into checkpointers, which hold thread-scoped state, and stores, which hold memory across threads. The in-memory savers lose everything when the process restarts, so production calls for a database checkpointer such as Postgres, MongoDB, Redis or Oracle. CrewAI's migration guide argues that Flow persistence is built in while LangGraph needs a separately configured checkpointer. That holds locally. On LangSmith Agent Server, LangChain says persistence is handled for you.

### Retries, timeouts and runaway loops

LangGraph handles failure at the node. Each node can carry a retry policy, three attempts by default including the first, a timeout on async nodes from version 1.2, and an error handler that runs after retries are spent and can route to a compensation step. **Retries rerun the whole node**, so delivery is at-least-once and anything like a payment needs an idempotency key. CrewAI works at the task and agent level instead: guardrails retry a task up to three times by default, agents take `max_iter`, `max_execution_time` and `max_rpm` caps, and since October 2026 the fifth identical tool call, with the same tool, arguments and result, stops the task.

### Approvals and rewinds

CrewAI's `@human_feedback` decorator, from version 1.8.0, pauses a Flow for review; with outcomes set, a model maps free-form feedback to approve, reject or revise and routes the run, and a custom provider can collect that feedback through Slack, email or a webhook. LangGraph's `interrupt()` can pause anywhere but needs a checkpointer and a thread ID, and on resume the node restarts from its beginning, so code before the pause runs again. Its time travel replays from an earlier checkpoint or forks one with edited state. Later nodes re-execute, model calls included.

| Question | CrewAI | LangGraph |
|---|---|---|
| Basic unit | Agents with roles, tasks, crews; Flows for control | State, nodes and edges in a compiled graph |
| Saved state | `@persist` (SQLite default), task checkpoints | Checkpointers you configure; automatic on Agent Server |
| Failure handling | Task guardrail retries, agent caps, fifth identical tool call stops the task | Per-node retry policy, timeout, error handler |
| Human pause | `@human_feedback` in Flows | `interrupt()` anywhere, resumed by thread ID |
| Going back | Fork a checkpoint; replay from the latest kickoff | Replay or fork any prior checkpoint |
| Visual tool | Studio, a no-code builder in AMP | LangSmith Studio, a local debugging IDE |


> 💡 **Make retried steps idempotent:** A LangGraph retry reruns the whole node, so a payment or email step needs an idempotency key to avoid repeats.


## Studio names two very different tools

CrewAI's Studio sits inside AMP on both the Basic and Enterprise plans. You describe the job to a Crew Assistant that generates agents, tasks, tools and inputs, then adjust them on a visual canvas and test runs before publishing. It needs an LLM connection with your own OpenAI or Azure key, so tokens bill to that provider. One limit matters: export is one-way. Downloaded code cannot be imported back, and redeploying it creates a separate automation without the visual editor.

LangSmith Studio is a free visual interface for developing and testing LangGraph agents on your own machine. It needs a LangSmith account and API key, and it lets you inspect state at every node, edit state mid-run and replay from an earlier checkpoint. The local dev server behind it, started with `langgraph dev`, needs Python 3.11 or newer. **One builds agents for people who would rather not code; the other debugs graphs for people who do.** If the second describes your team, the [CrewAI tutorial](/articles/crewai-tutorial) shows how much code the framework route still asks for.

## Deployment, and who sends which bill

On AMP, every deployed crew or flow becomes an automation with its own API, triggers and traces, pushed from GitHub, another Git provider, a ZIP file or the CLI. Basic is Free: 2 automations, 50 workflow executions a month, a maximum of 50 and no additional executions, on CrewAI cloud only. By our arithmetic, 50 a month is about 1.7 a day on a 30-day month. Enterprise is Custom, reached through a Request trial button, with executions sized to the workflow, flexible overage and a choice of CrewAI cloud, your own VPC or your own infrastructure. The pricing page prints no dollar figure and no billing period.

LangChain draws its line at deployment rather than at runs. LangSmith Developer costs $0 per seat a month for 1 seat and up to 5k base traces a month. LangSmith Plus costs $39 per seat a month with up to 10k base traces, unlimited seats and pay-as-you-go usage beyond that, and it includes one free small serverless Agent Server. Cloud deployments of LangGraph agents require Plus or Enterprise. Additional servers bill on the compute and database resources they request, at a rate the docs do not print.

By our arithmetic, five Plus seats come to $195 a month, before any pay-as-you-go traces or extra server resources. Enterprise is custom, invoiced annually upfront, and is required for self-hosting with a control plane. Neither side covers your model bill: both frameworks call your provider on your own keys. Paid tool APIs, such as a search key, are billed by those services too.


> ⚠ **Hosting is billed differently:** CrewAI AMP Basic includes 50 workflow executions a month, which is also the maximum, and offers no additional executions; LangSmith Agent Server compute beyond the one free small server has no printed rate.


## What reviewers say about CrewAI


**What users rate it, by platform**

| Platform | Rating | Reviews | As of |
|---|---|---|---|


_Rendered from our current record; these are other platforms' user scores, separate from our own Toolkit Score._


Reviewers on G2 mostly praise how CrewAI splits a complex job into role-based agents and how fast multi-agent prototypes come together. The recurring complaints are token use and run time that grow quickly with multi-agent workflows, and agents that can loop on tools. One reviewer adds that production use needs more work on guardrails, state and error handling, and another found open-source CrewAI lighter on control and tracing than graph frameworks. Those complaints line up with the trade described above. Speed of setup comes from the prescribed roles. The control gap is what LangGraph sells. If neither framework fits, our [CrewAI alternatives](/articles/crewai-alternatives) covers hosted agent builders as well.


## FAQ

**Can a CrewAI crew run on LangSmith Agent Server?**

LangChain's docs say Agent Server is framework-agnostic and that CrewAI agents deploy through the same CLI once they expose a graph from langgraph.json.

**Does CrewAI need LangChain installed?**

No. The crewai package states it does not depend on LangChain or other agent frameworks, though its agents can still use LangChain and LlamaIndex tools.

**Which Python versions do they need?**

CrewAI needs Python 3.10 or newer and below 3.14. LangGraph's local dev server and CLI need Python 3.11 or newer.

**Is my data used to train models?**

LangSmith says it does not use customer traces, prompts or outputs to train models. CrewAI's Terms let it use Customer Data, including outputs, to improve its services and train models.


## Choosing between a crew and a graph

Choose CrewAI when the job reads like a team brief, you want something running quickly, a free hosted plan to try it on, and a no-code Studio for colleagues who will never open a Python file; wrap the crews in Flows once the steps must run in a fixed order. Choose LangGraph when your engineers want every branch, retry and pause written out explicitly, need to rewind and fork runs while debugging, and accept deploying through LangSmith Plus or Enterprise with extra server compute billed on top. Teams unsure which camp they sit in should build the same small job in both. Expect the graph to take more code.



## Sources

[1] CrewAI pricing — https://crewai.com/pricing (2026-11)
[2] CrewAI documentation: Installation — https://docs.crewai.com/en/installation
[3] CrewAI Terms of Use — https://crewai.com/terms-of-use
[4] AWS Marketplace: CrewAI Enterprise Platform reviews (from G2) — https://aws.amazon.com/marketplace/reviews/reviews-list/prodview-2lisdk6meykru