The frameworks disagree about what an agent even is
Four frameworks currently anchor most agentic-system builds, and they disagree at a level deeper than syntax: each one encodes a different answer to "what is the fundamental unit of orchestration." LangGraph says it's a node in an explicit state graph. CrewAI says it's a role with a goal, on a crew. AutoGen says it's a participant in a conversation. Google's ADK says it's a composable agent that can itself contain sub-agents. Picking a framework before understanding which of those four mental models matches your actual problem is how teams end up fighting their tooling for months.
This isn't a feature checklist -- feature parity between these four changes every quarter. It's a comparison of the assumption baked into each one's core abstraction, because that assumption is what survives every version bump and is genuinely hard to work around once a codebase commits to it.
LangGraph: agents as an explicit state graph
LangGraph's unit is a node in a graph, and the graph's edges -- including conditional edges that branch on the current state -- are declared up front. An agent run is a walk through that graph: state flows node to node, each node reads and writes a shared state object, and the graph's shape is inspectable before anything runs. This is the framework most willing to make you draw the whole workflow before you write a line of prompt.
What that buys: the control flow is never implicit. You can look at the graph definition and know exactly which states can lead where, which is exactly the property this site's own agent state machine article argues for when a workflow shape is known and fixed. Cycles (an agent looping back to re-plan) are first-class, not a workaround. Persistence and resumability -- checkpointing the state object mid-run -- are built into the same abstraction, not bolted on.
What it costs: you pay the graph-drawing tax even for simple, mostly-linear workflows, and a genuinely open-ended "figure out the steps as you go" agent (the domain of ReAct-style interleaved reasoning) fights the model, because you're forced to pre-declare transitions for behavior that's supposed to be dynamic. LangGraph is the strongest fit when the workflow's shape is knowable in advance and you want that shape enforced, not merely documented.
CrewAI: agents as roles on a crew
CrewAI's unit is a role -- an agent defined by a persona, a goal, and a backstory, assigned tasks, and grouped with other roles into a crew that executes a process (sequential or hierarchical, with a manager agent delegating). The abstraction is organizational, borrowed directly from how a human team is described in a project brief, and that's deliberate: it's the fastest framework to get a multi-agent demo running in, because "define three roles and describe what each does" maps directly onto how people already think about dividing work.
What that buys: low ceremony for the common case of "a few specialized agents collaborating on a bounded task" -- a researcher role, a writer role, a reviewer role, with CrewAI handling hand-off between them. The role/goal/backstory framing also turns out to be a genuinely useful prompt-engineering forcing function: writing a clear backstory tends to produce a better-behaved agent than writing a bare system prompt, because it forces scope statement.
What it costs: the organizational metaphor doesn't map cleanly onto workflows that aren't naturally role-shaped -- a single agent iterating through a long tool-use loop doesn't benefit from being told it's "a crew of one," and the hierarchical process's manager-delegates-to-workers pattern can become a black box exactly where LangGraph's explicit graph would still be inspectable. CrewAI is the strongest fit for a small number of clearly-differentiated specialist roles collaborating on a bounded, describable task.