Contrast CrewAI role-driven model with LangGraph state-driven graph

**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.