LangChain vs CrewAI vs AutoGen: The AI Agent Framework Playbook

A team ships a customer-support agent on Microsoft's AutoGen in March, and by November the framework's own homepage tells them to stop. The banner is not ambiguous: "Project archived and no longer maintained. Microsoft is not providing bug fixes, security fixes, new features, or support. We continue to advise against production use." The framework did not get worse. Its maintenance status did — and in agent infrastructure, maintenance status is a cost line.

The three frameworks, as they stand

Agent frameworks move fast enough that a six-month-old tutorial can describe an API that no longer exists. LangChain 1.0, announced October 22, 2025, is built on the LangGraph runtime — the framework's own docs describe the model plainly: "Agent = Model + Harness." The model reasons; the harness runs the loop, calls the tools, and keeps the state.

LangChain: the harness, and the bill that comes with it

LangChain's minimal harness is 'create_agent' — a model, a set of tools, and a loop. Underneath it sits LangGraph, the low-level orchestration layer where the agent is a graph of nodes and edges: state flows through the graph, each node is a step, and the developer controls exactly where the loop can branch, retry, or stop. Deep Agents is the managed variant — the same runtime, with the harness decisions made by the framework.

The strength is control. A LangGraph agent's state is explicit: the developer defines the state schema, and every step reads and writes it. Checkpointing is built in, so a failed run can resume from the last good step instead of replaying the whole task. The weakness is surface area. LangChain is a large SDK, and the 1.0 release is a breaking change from the 0.x line — code written against 0.3 tutorials needs migration, not just a version bump.

LangSmith is where LangChain's pricing lives. The Developer tier is $0 per seat with 5,000 base traces a month. The Plus tier is $39 per seat with 10,000 base traces a month. Usage beyond the base is metered in LangSmith Units at $1.00 per LSU. What LangSmith does not publish is the conversion from traces to LSUs, so no one can compute the overage bill from the pricing page alone. A team budgeting LangSmith must treat the trace allowance as the only number it can plan against.

CrewAI: roles, Flows, and a price per execution

CrewAI organizes agents the way a newsroom organizes reporters: a Crew is a set of role-playing agents with a shared goal, each with a role, a goal, and a backstory that shapes how it uses its tools. Delegation is built in — an agent can hand a subtask to another agent in the crew. Alongside Crews sits Flows, the state-management layer: event-driven, with explicit control flow and state that persists across steps. Crews decide who does what; Flows decide what happens next.

Memory, checkpointing, MCP tool servers, and human-in-the-loop approval are all documented as first-class features, and CrewAI is standalone — it does not depend on LangChain.

The pricing is where the documentation goes quiet. CrewAI's pricing page is JavaScript-rendered, and its static HTML carries no prices at all. The live page, as read in November 2026, shows a Basic tier at $0 for 50 executions a month and an Enterprise tier on custom quote — and nothing between them. A $99-a-month Basic contract exists only on the AWS Marketplace listing, for 100 executions. Secondary reports quote other figures, but none of those is CrewAI's published price. The honest statement is the gap: a team that needs more than 50 executions a month cannot find its price on CrewAI's own site, and must get a quote. That is a budgeting risk LangChain does not have, because LangSmith publishes its numbers.

AutoGen: archived, and what replaces it

AutoGen 0.7.5 is the last stable release, dated September 30, 2025. Its architecture is two layers: AgentChat, the high-level multi-agent conversation framework with GroupChat, and Core, the runtime underneath it. GroupChat is the signature pattern — several agents in a shared conversation, taking turns, with a selector deciding who speaks next. It is the pattern with the highest token cost in this playbook, because every agent in the conversation reads the shared history.

The archive banner is the whole story for new projects. No bug fixes, no security fixes, no new features, no support. Existing production deployments do not stop working on the day a project is archived — but every month without a security patch increases the audit risk. Microsoft's named successor is Microsoft Agent Framework, version 1.0 announced April 3, 2026. A team on AutoGen has three honest options: stay and accept the risk, migrate to Microsoft Agent Framework, or migrate to LangChain or CrewAI. Staying is a decision, not a default.

Memory and state: where the three diverge

LangGraph's checkpointing stores the graph state at every step, so a run can be inspected, resumed, or rewound. CrewAI's Flows carry state across steps by design, with memory scoped to agents and crews, and checkpointing that lets a Flow resume. AutoGen keeps conversation state in memory by default — the GroupChat history is the state — which is simple to reason about and expensive to run, because every new turn re-reads the whole conversation.

The practical consequence is replay cost. When a step fails, a framework without checkpoints replays the whole task; a framework with checkpoints replays one step. The money section prices that difference.

Tool use and MCP

All three frameworks call tools, and all three now speak MCP — the Model Context Protocol that lets an agent use a tool server without a custom integration per tool. LangChain's tool interface is the most mature, with a large ecosystem of prebuilt integrations in its SDK. CrewAI documents MCP support alongside its own tool framework, with tools declared per role. AutoGen's tool support is solid but frozen at 0.7.5. The evaluation question is whether the tools a team needs already exist for a framework, and whether the interface is stable across versions.

The money: token math at stated volumes

Every cost in this section is derived from one published price and one stated workload profile. The price is OpenAI's published Standard pricing for gpt-6.1-sol: $2.00 per million input tokens, $10.00 per million output tokens, $0.10 per million cached input tokens. The profile is our editorial yardstick, not a benchmark: one task is 6 model calls, each with 4,000 input tokens and 1,200 output tokens. The profile exists so the three frameworks can be compared on the same arithmetic.

One model call costs:

A single-agent LangChain task makes 6 calls. A three-agent CrewAI crew makes 12 calls, because each agent reads the shared context and calls the model for its own turn. An AutoGen GroupChat with the same three agents makes 15 calls, because the shared conversation history is re-read on every turn. The per-task cost follows:

CrewAI costs 2.0 times the single-agent baseline per task; AutoGen costs 2.5 times. The multiplier is the architecture: more agents in the loop means more model calls on the same work.

Two levers change the numbers. First, checkpointing: a failed task without checkpoints replays all 6 calls at $0.12; with checkpoints it replays one step at $0.020 — a saving of $0.10 per failed task. At a stated 5% failure rate on 10,000 tasks a month, that is $50 a month:

The second lever is caching: if 70% of input tokens are cached at $0.10 per million instead of $2.00, the per-call cost falls to about $0.015 and the single-agent task to about $0.09 — a 27% saving. Both levers are available on LangChain and CrewAI; on AutoGen they are available only as far as the frozen 0.7.5 release supports them.

Then the hosted bill. LangSmith Plus at 5 seats is $195 a month, and 10,000 tasks produce 10,000 traces — exactly the 10,000 base traces the Plus tier includes, so no overage on the stated profile. But the traces-to-LSU conversion is unpublished, so a team that exceeds the base cannot compute its overage. CrewAI's hosted bill cannot be computed at all from its own site above 50 executions a month. The token math is the only cost a team can calculate in advance.

The decision table

Evaluate before you commit

1. Fix the workload profile. Write down the calls per task, the tokens per call, and the monthly task volume. Without the profile, no framework comparison is reproducible.
2. Build the same task on two frameworks. One retrieval task, one multi-step task, one task with a tool call. Measure the calls per task on each.
3. Price the hosted layer. LangSmith Plus at your seat count against your trace volume; CrewAI by quote above 50 executions a month.
4. Test the failure path. Kill a run mid-task and measure the replay cost.
5. Check the license and the maintenance status. All three are MIT — the difference is not the license, it is whether anyone is still fixing bugs.

• [x] Workload profile written: calls per task, tokens per call, monthly volume.
• [x] Same task built on two frameworks: calls per task measured, not assumed.
• [x] Hosted layer priced: LangSmith seats and traces, or CrewAI quote in hand.
• [x] Failure path tested: replay cost measured with and without checkpoints.
• [x] Maintenance status checked: no archived framework in a new build without a written risk decision.
• [x] License confirmed: MIT for all three; AutoGen docs under CC BY 4.0.

Who should NOT use each framework

Do not build a new project on AutoGen. The archive banner is the verdict, and the migration path is named. Do not pick CrewAI if you need a published paid price before you commit budget — the gap between 50 free executions a month and an Enterprise quote is a procurement conversation. Do not pick LangChain if your team will not maintain the harness: the control LangGraph gives is only useful if someone owns the graph and the state schema. And do not pick any multi-agent framework for a task one agent can do — the 2.0× and 2.5× multipliers are the price of agents talking to each other, and a single agent at $0.12 a task beats a crew at $0.24 when the crew adds no capability.

The verdict, in one paragraph

LangChain is the default for teams that want control and a published price: the lowest per-task cost on the stated profile, checkpointing that pays for itself, and a hosted layer with numbers. CrewAI is the pick for role-based multi-agent work where delegation and human approval matter more than the per-task multiplier — provided the team gets its quote before it builds. AutoGen is finished as a new-build choice; its users should migrate to Microsoft Agent Framework. Run the token math on your own profile in the pricing calculator, and read our autonomous agents production architecture and the LLM API pricing playbook for the blueprint and the model prices the math is built on.