LangGraph vs CrewAI vs Claude Code: Picking an AI Agent Framework

Every comparison piece on this topic does the same thing: LangGraph has more nodes, CrewAI has more built-in roles, here's a feature table, pick one. Coursera's specialization frames it as a curriculum decision — take the modules, learn the APIs, graduate with an opinion. Microsoft's own "which framework to use" episode frames it as an SDK bake-off — throughput, ecosystem, docs quality. Neither question is the one that actually decides your outcome. After running a fleet that's grown past 325 agents across 110+ repos, the choice that mattered wasn't which AI agent framework had the most GitHub stars. It was which coordination model matched the shape of the problem I was solving.

That distinction sounds academic until you've shipped the wrong one. I have. Twice.

The Feature Checklist Is the Wrong Frame

Feature comparisons ask: does it support streaming? Does it have built-in memory? Can it call tools? Almost every serious option — LangGraph, CrewAI, AutoGen, Claude Code — answers yes to all three now. Tool calling is table stakes. Memory is table stakes. Streaming is table stakes. If you're choosing based on a checkbox grid, you'll end up picking whichever one has the prettiest docs site, and you'll find out the real problem eighteen months in when you're trying to add a fourth agent to a system that was only ever designed to coordinate two.

The question that actually predicts whether you'll be happy in a year is simpler and less technical: how do your agents need to hand work to each other? That's a coordination-model question, not a feature question, and it's the same argument I make at length in AI Agents in Production: The Operator's Handbook — the framework is downstream of the architecture, not the other way around.

There are three real answers, and each one maps to a different tool.

LangGraph: When You Need an Explicit State Graph

LangGraph wins when the workflow is genuinely a graph — named nodes, conditional edges, and state that has to survive a crash or a five-minute human approval pause. It's built for durability: checkpointed state, resumable execution, deterministic transitions you can replay and audit. If you're building a loan-approval pipeline, a multi-step compliance review, or anything where "show me exactly how this reached node 7" is a requirement someone will actually ask for, LangGraph's graph-as-source-of-truth model earns its complexity.

The cost is that you're writing and maintaining the graph. Every new branch is a new edge you define by hand. That's a feature when the process is regulated and stable. It's friction when the process is still being discovered — and most processes, when you're honest about it, are still being discovered for the first six months.

I'd reach for LangGraph again for anything with a compliance officer attached to the outcome. Human-in-the-loop approval gates are a first-class citizen in a graph model in a way they're bolted on everywhere else — you pause at a node, wait for a real person, resume exactly where you left off with full state intact. That's worth the hand-wiring when the alternative is explaining to an auditor why the agent's decision path can't be reconstructed.

CrewAI: When You Need a Role-Based Crew

CrewAI wins when the mental model is genuinely a team — a researcher, a writer, an editor, each with a defined role and a manager coordinating handoff. It's the fastest path from zero to "four agents talking to each other" because the abstraction (role, goal, backstory, task) maps directly onto how humans already think about delegating work. For a fixed pipeline with a small, stable cast of roles, that's real leverage — you're not hand-wiring a graph, you're describing a team and letting the framework route the handoff.

The cost shows up at the edges: when a task doesn't cleanly belong to one role, or when you need the crew's shape to change based on what the first agent found, the role abstraction starts fighting you instead of helping. You end up either stretching one role's job description until it's meaningless, or adding a fourth agent whose entire purpose is deciding which of the other three should handle the edge case — which is coordination overhead the framework didn't save you from, it just moved it.

Claude Code: One Capable Agent, Not Three

This is the model I actually run production on, and it's the one most comparisons undersell because it doesn't look like "multi-agent" in the marketing sense. Claude Code's default unit isn't a crew of pre-assigned roles — it's one capable agent that gets extended with skills, dispatches subagents only when a task genuinely needs isolation, and uses hooks for the deterministic guardrails you don't want an LLM deciding at runtime. Coordination happens through file-territory ownership and messaging between spawned agents, not a fixed org chart baked in before you know what the work looks like.

That distinction — one agent extended with capability versus N agents assigned fixed roles — is exactly the taxonomy I lay out in 5 AI Agent Design Patterns That Survive Production. It also shows up as the tech-stack decision behind the fleet numbers I keep citing, which I go deeper on in The AI Agent Tech Stack Behind 325 Agents in Production.

What Running 325 Agents Actually Taught Me

None of this was a whiteboard exercise. It came from watching real coordination failures in production — a crew-style setup where two role-agents both assumed they owned the same file and silently clobbered each other's work, because the role abstraction told each of them they were the one responsible for that output; a graph pipeline that got so branch-heavy that debugging a single failed run meant tracing eleven conditional edges by hand, and the "audit trail" that was supposed to be the whole point became its own investigation. Both failures were coordination-model failures, not framework bugs. The tools did exactly what they were built to do — I'd just matched the wrong tool to the wrong shape of problem.

Here's roughly what a single-agent-plus-skills dispatch looks like in practice — this is the actual shape of how I hand off isolated work without pre-assigning a fixed crew:

Agent({
  description: "Security review of the payments worker",
  subagent_type: "security-team",
  prompt: "Review workers/payments/src/index.ts for auth bypass
    and injection risk before this ships. Report findings only —
    no fixes without sign-off."
})

No pre-declared role roster, no graph edge to define ahead of time. The main agent decides, at the moment it needs isolation, that this particular task warrants a subagent with a narrower tool surface. That's the entire coordination model: one operator, dispatching capability on demand, instead of a standing team that has to be reorganized every time the work changes shape.

How to Actually Choose an AI Agent Framework

Skip the feature table and answer one question instead: does your process need to be provable, does it need to be teamlike, or does it need to be adaptive?

• Provable — regulated, auditable, state must survive a crash → LangGraph.
• Teamlike — a small, stable cast of roles handing off a known pipeline → CrewAI.
• Adaptive — the shape of the work changes session to session, and you need one operator that can reach for new capability without redesigning an org chart → Claude Code.

Most teams doing this evaluation are actually weighing all three against a problem that hasn't fully revealed its shape yet. That's fine — pick the coordination model that matches today's problem, and don't be precious about switching when the shape changes. I've moved workloads between all three. The SDK migration was never the hard part. Misreading the coordination model up front was.

None of this is exclusive, either. A production system can run LangGraph for the one regulated approval flow that needs a durable audit trail, while everything upstream of it runs as a single Claude Code operator dispatching subagents on demand. I run exactly that split today — the coordination model is a per-workflow decision, not a company-wide platform bet you make once and live with forever.

The Choice That Actually Matters

The trading infrastructure behind tesseractintelligence.io runs on the same principle: the coordination model gets decided before a single SDK import gets written, because retrofitting it later means rearchitecting, not refactoring. That's true whether you're building a research pipeline, a support triage system, or a fleet of coding agents. Pick LangGraph if you need proof. Pick CrewAI if you need a team. Pick Claude Code if you need one operator who can grow into whatever the work turns out to require.

Start with the 7 free skills at jeremyknox.ai/skills-library — no signup. pressure-test is the one I'd run first against your own framework pick — it's built to stress-test a decision like this one before you've sunk three months into the wrong coordination model.