CrewAI vs LangGraph: roles vs graphs for agent orchestration

When you evaluate crewai vs langgraph agent orchestration, the fundamental difference isn’t feature parity — it’s mental model. CrewAI asks you to think in roles and delegation; LangGraph asks you to think in nodes, edges, and state machines. That distinction cascades into everything: how you debug, how you scale, how you version, and how you explain the system to the next engineer who inherits it.

Core philosophy: roles vs graphs

CrewAI models a workplace. You define agents with roles (“senior researcher,” “fact checker”), give them goals, and let them delegate tasks through a manager or sequential process. The framework handles the conversation loop. You’re writing job descriptions, not control flow.

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Researcher",
    goal="Find the latest developments in RAG evaluation",
    backstory="You've published 20 papers on retrieval systems.",
    tools=[search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Summarize findings for an engineering audience",
    backstory="You translate research into blog posts.",
    verbose=True,
)

research_task = Task(
    description="Identify 5 key papers from the last 6 months on RAG evaluation metrics",
    agent=researcher,
    expected_output="Bulleted list with citations and one-sentence summaries",
)

write_task = Task(
    description="Write a 800-word summary for senior engineers",
    agent=writer,
    expected_output="Markdown article with sections",
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
)

result = crew.kickoff()

LangGraph models a state machine. You define a graph where nodes are functions (LLM calls, tool invocations, deterministic code) and edges determine what runs next. State is an explicit, typed object that flows through the graph. You’re writing a program, not a screenplay.

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class ResearchState(TypedDict):
    topic: str
    papers: Annotated[list, operator.add]
    summary: str
    iteration: int

def search_node(state: ResearchState):
    results = search_tool.invoke(state["topic"])
    return {"papers": results, "iteration": state["iteration"] + 1}

def summarize_node(state: ResearchState):
    prompt = f"Summarize these papers for engineers: {state['papers']}"
    summary = llm.invoke(prompt)
    return {"summary": summary.content}

def should_continue(state: ResearchState):
    return "summarize" if state["iteration"] >= 1 else "search"

workflow = StateGraph(ResearchState)
workflow.add_node("search", search_node)
workflow.add_node("summarize", summarize_node)
workflow.set_entry_point("search")
workflow.add_conditional_edges("search", should_continue)
workflow.add_edge("summarize", END)

app = workflow.compile()
result = app.invoke({"topic": "RAG evaluation metrics", "iteration": 0})

The CrewAI version reads like a spec document. The LangGraph version reads like code. Neither is wrong — but they attract different teams and solve different problems.

State management and control flow

CrewAI hides state inside the crew’s execution loop. Tasks produce outputs that become context for downstream tasks. You can pass context=[task1, task2] explicitly, but the framework decides when and how to inject that context into the agent’s prompt. This works well for linear or lightly branching workflows. It breaks down when you need:

• Cycles with convergence criteria (e.g., “refine until quality score > 0.9”)
• Parallel fan-out/fan-in with partial failure handling
• Human-in-the-loop checkpoints that can resume from arbitrary points
• Dynamic routing based on intermediate computation, not just LLM output

LangGraph makes all of this explicit. State is a TypedDict you define. Nodes return partial state updates merged via reducers (the Annotated[list, operator.add] pattern). Conditional edges are pure Python functions that inspect state and return the next node name. You can pause at any node, serialize state to a database, and resume days later.

# LangGraph: human-in-the-loop with interrupt
from langgraph.types import interrupt, Command

def human_review_node(state: ResearchState):
    review = interrupt({
        "question": "Approve this summary?",
        "summary": state["summary"]
    })
    if review["approved"]:
        return {"status": "approved"}
    else:
        return {"summary": review["revised_summary"], "status": "rejected"}

workflow.add_node("human_review", human_review_node)
workflow.add_edge("summarize", "human_review")
workflow.add_conditional_edges(
    "human_review",
    lambda s: "end" if s["status"] == "approved" else "summarize"
)

CrewAI added human_input=True on tasks, but it blocks the entire process and doesn’t support structured review payloads or mid-execution state mutation.

Developer ergonomics

CrewAI optimizes for “time to first demo.” The declarative API, built-in verbose logging, and role-playing metaphors let a solo engineer produce a working multi-agent system in an afternoon. The framework handles prompt construction, tool binding, and conversation memory automatically. You don’t think about token budgets or context window management until you hit limits.

LangGraph optimizes for “time to production correctness.” You write more boilerplate — state schema, node functions, edge definitions — but you get type safety, testable units, and explicit control over every token. The learning curve is steeper because you’re effectively learning a lightweight workflow engine, not just an agent library.

Testing illustrates the difference. CrewAI tasks are integration tests by default; you mock the LLM and assert on final output. LangGraph nodes are unit-testable pure functions:

# LangGraph: trivial to unit test
def test_search_node():
    state = {"topic": "test", "papers": [], "iteration": 0}
    result = search_node(state)
    assert "papers" in result
    assert result["iteration"] == 1

# CrewAI: requires mocking the whole crew execution
@patch("crewai.Agent.execute_task")
def test_research_task(mock_execute):
    mock_execute.return_value = "paper list"
    result = research_task.execute()
    assert "paper" in result.lower()

CrewAI’s verbose=True gives you colored console output that’s great for demos. LangGraph’s app.stream() yields state deltas at each node — better for building custom UIs or logging pipelines.

Ecosystem and integrations

CrewAI bundles integrations: 50+ tools (Serper, Browserbase, various APIs) work out of the box with a consistent interface. The crewai-tools package is maintained by the core team. If your use case is “agents that browse, search, and call APIs,” you move fast.

LangGraph delegates to LangChain’s tool ecosystem. You get breadth (hundreds of tools) but less consistency — some tools return strings, others dicts, some handle auth differently. You’ll write more adapter code. However, LangGraph integrates natively with LangSmith for tracing, evaluation datasets, and prompt versioning. CrewAI has its own tracing (CrewAI Enterprise) and community integrations with Langfuse, but the first-party story is weaker.

Both support OpenAI-compatible endpoints. If you’re routing through a gateway that handles fallback and usage metering across 240+ models, both frameworks just work — you pass the base URL and API key to the underlying LLM client.

Observability and debugging

CrewAI’s verbose=True prints the full agent loop: thoughts, tool calls, observations, final answers. It’s readable but unstructured. You can’t easily query “show me all tool calls that returned errors” without parsing logs.

LangGraph’s streaming API emits structured events:

for chunk in app.stream(input_state, stream_mode="values"):
    print(chunk.keys())  # {'papers': [...], 'iteration': 1}
    # or stream_mode="updates" for node-level deltas

LangSmith captures the full trace automatically: inputs, outputs, latency, token counts, and the graph topology. You can replay a failed run, modify a node’s prompt, and re-run from that node — a feature that saves hours during incident response.

CrewAI added crewai.telemetry hooks recently, but they’re not as mature.

Deployment and operational concerns

CrewAI crews are stateless by default — each kickoff() starts fresh. For long-running processes, you need to persist task outputs yourself and reconstruct context on retry. The framework doesn’t help with idempotency keys or exactly-once semantics.

LangGraph’s checkpointing (via MemorySaver, SqliteSaver, or PostgresSaver) serializes full state after every node. You get resume-from-failure for free. The PostgresSaver supports horizontal scaling: multiple workers can pull from a queue, each loading state from the database.

from langgraph.checkpoint.postgres import PostgresSaver

with PostgresSaver.from_conn_string(POSTGRES_URL) as checkpointer:
    app = workflow.compile(checkpointer=checkpointer)
    # Resume from thread_id
    result = app.invoke(input_state, config={"configurable": {"thread_id": "run-123"}})

CrewAI’s Process.hierarchical adds a manager agent that decomposes tasks and delegates. It’s clever but opaque — the manager’s prompts are internal, and you can’t easily constrain its delegation logic. LangGraph’s equivalent is a router node you write yourself:

def router_node(state: ResearchState):
    if len(state["papers"]) < 3:
        return "search"
    elif "summary" not in state:
        return "summarize"
    else:
        return "human_review"

You own the logic. You can version it, test it, and change it without prompt engineering.

Comparison table

Which to choose

Choose CrewAI when:

• You’re building a prototype or internal tool where the workflow is mostly linear or lightly branched
• Your team thinks in roles and delegation — product managers can read and review the agent definitions
• You want to move fast with minimal boilerplate and don’t need fine-grained control over token usage or context construction
• The task maps naturally to “research → analyze → write” or similar sequential pipelines
• You value the bundled tool integrations and don’t want to maintain adapters

Choose LangGraph when:

• You need cycles, convergence loops, or dynamic routing based on computed state (not just LLM output)
• Human-in-the-loop is a first-class requirement with structured review payloads and resume capability
• You’re building a system that must survive process crashes, scale horizontally, or support audit trails
• Your team prefers type-safe, testable code over declarative configuration
• You already use LangSmith or want structured observability out of the box
• You’re composing multiple graphs as subgraphs in a larger system

The hybrid reality: Many teams start with CrewAI for speed, hit a wall on control flow or observability, and migrate to LangGraph. The migration is mechanical — CrewAI tasks map to nodes, context passing maps to state reducers. If you suspect you’ll need graph semantics within six months, start with LangGraph. The upfront cost pays for itself the first time you need to debug a stuck loop or add a checkpoint.

If you’re routing through a gateway that handles model fallback and per-token metering across providers, both frameworks integrate cleanly — just configure the base URL on your LLM client and the gateway handles the rest.