All three are free, open-source (MIT) Python frameworks, and all three are model-agnostic - so the real cost is your LLM API usage, not the framework. Choose LangGraph for durable, long-running, stateful workflows and low-level control. Choose CrewAI to stand up role-based "teams" of agents fast. Choose the OpenAI Agents SDK for the lightest footprint and deep ties to OpenAI's tracing and tools. The hard part is never the framework - it is the evals and guardrails you put around it.
Pick an AI agent framework and you will find a hundred listicles ranking them, most written by people who have never shipped one past a demo. We ship agents in production for a living, so here is the comparison we wish those lists were: what each framework actually is, how it is built, and when we reach for it. Scoped to the three we build with most - LangGraph, CrewAI, and the OpenAI Agents SDK - and honest about where each one bites.
First, the thing the listicles bury: all three are free and open-source under the MIT license, and all three are model-agnostic. The framework is not where your money goes. Your bill is the underlying LLM API, and your risk is the engineering around the agent. Keep that in mind while everyone argues about syntax.
LangGraph - the control freak's framework (in a good way)
LangGraph, from LangChain Inc., describes itself as a "low-level orchestration framework for building stateful agents." You model the agent as a graph of nodes and edges with explicit state, which means you can mix deterministic, hand-coded steps and LLM-driven steps in the same flow.
Its standout feature is durable execution: checkpointing and persistence let an agent persist through failures and run for extended periods, resuming from where it left off. It has first-class human-in-the-loop (you can inspect and modify state mid-run), long- and short-term memory, streaming, and tracing via LangSmith. It is used in production by the kind of companies that do not accept flaky - LangChain cites Klarna, Uber, and J.P. Morgan.
The trade-off, widely reported by developers (so: opinion, not benchmark): the low-level power comes with a steeper learning curve and a more verbose API than the lighter options. You get control; you pay for it in ceremony. Note too that LangSmith (observability) and LangGraph Platform (managed deployment) are separate paid products - the library itself is free.
CrewAI - agents that work as a team
CrewAI is built around a different metaphor: crews of role-playing agents that collaborate on tasks, plus flows for event-driven, production-grade control. It is its own standalone framework (notably, not built on LangChain), and it is the most-starred of the three - tens of thousands of GitHub stars.
The appeal is speed to a working multi-agent setup: you define roles ("researcher," "writer," "reviewer"), give them tasks, and pick a process (sequential or hierarchical). It is model-agnostic through native integrations plus LiteLLM, so it talks to OpenAI, Anthropic, Gemini, Bedrock, and more.
The trade-off (again, developer opinion): the autonomous role-playing paradigm is fast to start but can be less predictable and offers less fine-grained control than LangGraph's explicit graph. CrewAI's answer to that is Flows, which add back deterministic structure - a sign the "just let the agents talk" model needed guardrails in production, same as everything else. CrewAI AMP is a separate managed platform; the open-source framework is free.
OpenAI Agents SDK - minimal on purpose
The OpenAI Agents SDK is the newest and the lightest. Its whole design philosophy is "enough features to be worth using, but few enough primitives to be quick to learn." Those primitives: Agents, Handoffs (one agent delegates to another), Guardrails (input/output validation), Sessions (automatic memory), and built-in Tracing.
If your stack already lives in OpenAI's world, this is the path of least resistance - tracing plugs straight into OpenAI's eval, fine-tuning, and distillation tools, and there are official Python and TypeScript SDKs. It is provider-agnostic on paper (it supports 100+ models via adapters) but OpenAI-oriented in its defaults.
Two honest flags. First, it is still pre-1.0 (version 0.x as of October 2026), which means a less settled API than the other two. Second, it does not headline the durable, resumable, long-running execution that LangGraph is built around - so for workflows that must survive restarts and run for hours, it is not the natural first pick. "Does not emphasize," to be precise - not "cannot."
A great framework with no evals is just a faster way to ship a liability.
When to choose each
| If you need... | Reach for | Why |
|---|---|---|
| Durable, long-running, resumable workflows with explicit state and checkpointing | LangGraph | The only one that headlines durable execution and graph-level state control |
| Maximum low-level control, mixing deterministic and LLM steps | LangGraph | Self-described "low-level orchestration framework" |
| To stand up role-based agent "teams" fast, with an optional control layer | CrewAI | Crews (collaboration) plus Flows (event-driven control) |
| The lightest footprint, quickest to learn, handoffs plus guardrails | OpenAI Agents SDK | Few primitives by design |
| Deep integration with OpenAI tracing, evals, and fine-tuning | OpenAI Agents SDK | Built-in tracing tied to OpenAI's suite |
| To swap model providers freely | Any of the three | All are model-agnostic; the OpenAI SDK leans most OpenAI-ward |
| An official TypeScript/JS SDK | LangGraph or OpenAI Agents SDK | Both ship official JS/TS; CrewAI is Python-only |
How we actually choose
Here is the part the comparison tables miss: in production, the framework is maybe 20% of the decision. We have shipped reliable agents on all three, and the thing that makes them reliable is identical regardless of which one we pick - a passing eval suite, deterministic guardrails around every consequential action, human-in-the-loop on the risky calls, and monitoring for drift.
So our real selection rule is boring: pick the framework whose model of the world matches the problem (durable state - LangGraph; fast multi-agent teams - CrewAI; minimal and OpenAI-native - the SDK), then spend your energy on the scaffolding that actually decides whether it survives contact with real users.
If you are choosing a framework for a real workload and want a second opinion from people who build on all three, tell us the use case - we will tell you which we would pick and why. You can also see how we build production agents in our AI agent development work.