CrewAI is described as 'role-driven' and LangGraph as 'state-driven.' Unpack what that means in terms of the core abstraction each one asks you to think in, and explain how that difference shows up in the kind of bugs each framework makes hard or easy.
Free · 2 AI evals / day
**CrewAI** asks you to think in people. Each unit of work is an `Agent` with a role, a goal, a backstory, and a tool list. Each piece of work is a `Task` with a description, an expected output, and an assigned agent. The `Process` (Sequential or Hierarchical) decides who runs in what order.
**LangGraph** asks you to think in state. You define a `State` schema (a TypedDict or Pydantic model) listing every field the workflow tracks. Each `Node` is a function that reads the state, does work (often an LLM call), and returns updates. Edges (especially conditional edges) decide which node runs next.
The two frameworks are not direct competitors; they solve different problems. CrewAI shines when the work is genuinely a team of specialists collaborating: a researcher gathers, an analyst synthesises, a writer drafts. LangGraph shines when the work is genuinely a pipeline with branches: an input arrives, gets classified, routes to one of three paths, optionally loops back for revision.
The bugs each framework invites are different, which is the load-bearing insight when you pick between them.
**Two abstraction shapes, two bug shapes.** CrewAI's core abstractions are `Agent`, `Task`, and `Process`. You write 'who does what and in what order.' Control flow is implicit in the process; Sequential runs tasks top to bottom, Hierarchical adds a manager LLM that decides delegation. The mental model is a team meeting.
LangGraph's core abstractions are `State`, `Node`, and `Edge` (especially `add_conditional_edges`). You write 'how state evolves and what edge runs next.' Control flow is explicit in the graph; you draw the diagram and the framework runs it. The mental model is a finite-state machine.
The bug categories follow the abstractions. CrewAI makes **role-bleed** easy: two agents with overlapping backstories produce similar outputs, the manager LLM mis-delegates, a chatty backstory leaks into the final answer. CrewAI makes **prompt-leak** easy too because the role + goal + backstory all concatenate into the system prompt.
LangGraph makes **state-merge** bugs easy: a list field without a reducer gets clobbered by concurrent nodes, a mutation of state inside a node creates phantom updates, a conditional edge with a misspelt return value silently routes to `END`. The framework gives you the graph but trusts your reducers.
The decision rule: shape of work picks the framework. Team of specialists work picks CrewAI. State-flowing through branches work picks LangGraph.
Quick reference
TL;DR
CrewAI gives you Agent + Task + Process; LangGraph gives you State + Node + Edge. The first invites role-bleed bugs, the second invites state-merge bugs.
Picture two ways to organise a kitchen. CrewAI is the brigade kitchen: each cook has a title (saucier, pastry chef, expediter), a backstory of training, and a list of dishes they own. You write the menu by saying who cooks what in what order. LangGraph is a dish-assembly line on a conveyor belt: a tray (the state) carries the dish from station to station, each station reads the tray, adds something, and passes it on, and a switch decides which station gets it next. Brigade kitchens go wrong when two cooks step on each other's roles. Conveyor belts go wrong when two stations write to the same spot on the tray and clobber each other.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Single-prompt workflows with no branching or specialisation Both frameworks are overkill for one prompt. The raw provider SDK is faster to write and easier to debug.
Workflows that need both team of specialists framing AND deep state persistence Neither framework is a clean fit. The pragmatic answer is LangGraph with personas encoded as node-level system prompts, accepting the verbosity.
Latency-critical hot paths where every millisecond matters Both frameworks add dispatch overhead, and CrewAI's manager-LLM step in Hierarchical mode adds a full LLM round trip per delegation decision.
Quick scan · 2–4 min
Everything important, quickly.
6 min: CrewAI's persona model + LangGraph's state-machine model + the bug categories each invites + production failure modes + when each fits + migration pattern.
Real-world examples
Real products, models, and research that use this idea.
1CrewAI's reference research-crew template (researcher + analyst + writer) is the canonical persona-orchestration example; ships in the CrewAI docs.
2LangGraph's create_react_agent and supervisor patterns power LangChain's own agent reference implementations in 2026.
3Devin (Cognition AI) reportedly uses a LangGraph-style state machine under the hood for its long-horizon coding work.
4Linear's AI features use LangGraph for the multi-step issue-triage flow where state needs to persist across user interrupts.
5Klarna's customer-support agent stack uses a hierarchical pattern more similar to CrewAI's persona orchestration for first-line routing.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhen would you actually pick CrewAI over LangGraph for production?
Sign in or go Pro to see the approach for this follow-up.
QWalk through a concrete LangGraph reducer bug you have seen or could imagine.
Sign in or go Pro to see the approach for this follow-up.
QHow does the OpenAI Swarm / Agents SDK fit on this axis?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Picking CrewAI for a pipeline that is really a state machine, then fighting role descriptions to encode branching logic. The shape of the work should pick the framework, not vice versa.