# LangGraph vs CrewAI vs AutoGen: how they differ and which to use

> LangGraph controls flow as a graph, CrewAI pairs role-based Crews with Flows, and AutoGen is archived in favor of Microsoft Agent Framework.

Source: https://www.honeyhive.ai/learn/langgraph-vs-crewai-vs-autogen (updated 2026-11-06)

LangGraph, CrewAI and AutoGen answer the same question, how several model calls and tools become one agent system, in three different ways. LangGraph gives you a graph: you write the nodes, edges and shared state, and its docs call it a [low-level orchestration framework](https://docs.langchain.com/oss/python/langgraph/overview). CrewAI gives you teams of role-based agents (Crews) and an event-driven layer (Flows) that, per its [introduction](https://docs.crewai.com/en/introduction), delegates tasks to them. AutoGen gave you conversational teams of agents, but its README now says the project is [archived and no longer maintained](https://github.com/microsoft/autogen), and Microsoft points new work to Microsoft Agent Framework. Many older comparisons still treat AutoGen as a live choice.

Each framework has its own page: [LangGraph](/learn/langgraph-framework), [CrewAI](/learn/crewai-framework) and [AutoGen](/learn/autogen-framework). This page puts the same criteria side by side.

## AutoGen is archived; Microsoft Agent Framework replaces it

The AutoGen README says Microsoft is ["not providing bug fixes, security fixes, new features, or support"](https://github.com/microsoft/autogen) and calls Microsoft Agent Framework "the enterprise-ready successor to AutoGen". Microsoft's overview says Agent Framework is ["the direct successor, created by the same teams"](https://learn.microsoft.com/en-us/agent-framework/overview/) as AutoGen and Semantic Kernel. Its migration guide says it is developed ["by the core AutoGen and Semantic Kernel teams"](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/).

What changed in the design, per that guide: AutoGen pairs an event-driven core with a high-level `Team`, while Agent Framework centers on a typed, graph-based `Workflow`. The guide also says AutoGen's `Team` has no built-in checkpointing, and that Agent Framework workflows support pauses for input and checkpoints. Agent Framework reached 1.0 for .NET and Python in [April 2026](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/), with sequential, concurrent, handoff, group chat and Magentic-One orchestration patterns. Its overview lists .NET, Python and Go, with Go in [public preview](https://learn.microsoft.com/en-us/agent-framework/overview/).

So the practical AutoGen question is no longer "LangGraph or CrewAI or AutoGen". It is whether you are keeping an existing AutoGen app (see the migration guide) or starting new, in which case Microsoft Agent Framework is the Microsoft option. The rows below describe AutoGen as documented, because that is what existing code and most tutorials use.

## Side by side

| | LangGraph | CrewAI | AutoGen |
|---|---|---|---|
| What it is | "A low-level orchestration framework and runtime for long-running, stateful agents" ([docs](https://docs.langchain.com/oss/python/langgraph/overview)) | "The leading open-source framework for orchestrating autonomous AI agents and building complex workflows" ([docs](https://docs.crewai.com/en/introduction)) | "A framework for creating multi-agent AI applications" ([README](https://github.com/microsoft/autogen)) |
| Status | Active; MIT ([GitHub](https://github.com/langchain-ai/langgraph)) | Active; MIT ([GitHub](https://github.com/crewAIInc/crewAI)) | Archived, no support from Microsoft; successor is Microsoft Agent Framework ([README](https://github.com/microsoft/autogen)) |
| Core abstraction | Graph of nodes and edges over shared state ([overview](/learn/langgraph-framework)) | Agents with role, goal and backstory, grouped into Crews; Flows chain them ([agents](https://docs.crewai.com/en/concepts/agents), [Flows](https://docs.crewai.com/en/concepts/flows)) | Agents grouped into Teams ([teams](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)) in AgentChat, built on an event-driven Core ([README](https://github.com/microsoft/autogen)) |
| Who writes the control flow | You. It "does not prescribe prompts or agent architecture" ([docs](https://docs.langchain.com/oss/python/langgraph/overview)) | Flows with `@start`, `@listen` and `@router`; Crews run sequentially or under a manager agent ([Flows](https://docs.crewai.com/en/concepts/flows), [Crews](https://docs.crewai.com/en/concepts/crews)) | Team presets: round robin, model-selected speaker, swarm handoffs, Magentic-One ([teams](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)) |
| State and resuming | Checkpointed state that lets runs "resume after failures or pauses" ([docs](https://docs.langchain.com/oss/python/langgraph/overview)) | Flow state as a dict or Pydantic model; `@persist` saves to SQLite by default and can resume by ID ([Flows](https://docs.crewai.com/en/concepts/flows)) | `save_state()` and `load_state` on agents and teams, written to a file or database by you ([state](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html)); no built-in team checkpointing ([migration guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/)) |
| Human in the loop | "Pause execution, inspect or edit state, then continue" ([docs](https://docs.langchain.com/oss/python/langgraph/overview)) | `@human_feedback` in Flows, CrewAI 1.8.0 or later ([Flows](https://docs.crewai.com/en/concepts/flows)) | A `UserProxyAgent` during a run, or input on the next `run()` after a termination condition; the proxy blocks the team and can leave it in a state that cannot be saved ([guide](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/human-in-the-loop.html)) |
| Multi-agent | Subagents, handoffs, routers or a custom LangGraph workflow ([LangChain docs](https://docs.langchain.com/oss/python/langchain/multi-agent)) | Crews with `allow_delegation` (off by default) and a hierarchical process with a manager ([agents](https://docs.crewai.com/en/concepts/agents), [Crews](https://docs.crewai.com/en/concepts/crews)) | Teams are the core idea: "a group of agents that work together to achieve a common goal" ([teams](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)) |
| MCP tools | Through LangChain's `MCPAdapter`, a beta namespace needing `langchain[mcp]>=1.4.0` ([docs](https://docs.langchain.com/oss/python/langchain/mcp)) | `mcps` field on agents; stdio, SSE and Streamable HTTPS ([docs](https://docs.crewai.com/en/mcp/overview)) | `mcp_server_tools()` in `autogen_ext.tools` ([extensions](https://microsoft.github.io/autogen/stable/user-guide/extensions-user-guide/index.html)) |
| Languages | Python, plus LangGraph.js ([GitHub](https://github.com/langchain-ai/langgraph)) | Python, `>=3.10 and <3.14` ([GitHub](https://github.com/crewAIInc/crewAI)) | Python 3.10 or later, with .NET packages for Core ([GitHub](https://github.com/microsoft/autogen)); successor covers .NET, Python and Go ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)) |
| Install | `pip install -U langgraph` | `uv tool install crewai` | `pip install -U "autogen-agentchat" "autogen-ext[openai]"` |

Install lines come from each README or overview linked above. For the general ideas behind the columns, see [multi-agent systems](/learn/multi-agent-systems) and [agent orchestration](/learn/agent-orchestration).

## LangGraph vs CrewAI

Both support stateful, long-running work with a pause for a person, and both can run several agents. The difference is who owns the flow.

In LangGraph you declare the structure. The docs separate workflows, which "have predetermined code paths", from agents, which "define their own processes and tool usage" ([workflows and agents](https://docs.langchain.com/oss/python/langgraph/workflows-agents)), and you can build either. In CrewAI the structure is split in two: Crews carry "flexible decision-making and dynamic interaction", and Flows carry "precise, event-driven control" ([GitHub FAQ](https://github.com/crewAIInc/crewAI)). The introduction says Crews are the teams a Flow delegates tasks to ([introduction](https://docs.crewai.com/en/introduction)).

| If you need | Lean toward |
|---|---|
| Loops, branches and parallel paths you design node by node | LangGraph |
| A team of role-described agents with delegation, with little graph code | CrewAI Crews |
| A typed workflow around a few agent teams | CrewAI Flows with a Pydantic state ([Flows](https://docs.crewai.com/en/concepts/flows)) |
| The same code in Python and JavaScript | LangGraph, which has [LangGraph.js](https://github.com/langchain-ai/langgraph) |
| A visual of the flow from code | CrewAI `flow.plot` ([Flows](https://docs.crewai.com/en/concepts/flows)) |

## CrewAI vs AutoGen

Both organize agents into groups that talk to each other. CrewAI's groups are Crews with a sequential or hierarchical process ([Crews](https://docs.crewai.com/en/concepts/crews)). AutoGen's are Teams with presets for turn order: round robin, a model choosing the next speaker, swarm handoffs and Magentic-One ([teams](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)).

The larger gap is maintenance. CrewAI is MIT licensed and its repository is current ([GitHub](https://github.com/crewAIInc/crewAI)); AutoGen is archived by Microsoft ([README](https://github.com/microsoft/autogen)). For persistence, CrewAI has `@persist` for Flows, while AutoGen leaves saving to you through `save_state()` ([state](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html)).

| If you need | Lean toward |
|---|---|
| A framework that still gets fixes and releases | CrewAI |
| Role, goal and backstory as the way you describe agents | CrewAI ([agents](https://docs.crewai.com/en/concepts/agents)) |
| Round-robin or selector group chats, in code you already have | AutoGen, with a plan to migrate |
| A Microsoft-supported route for new work | Microsoft Agent Framework ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)) |

## AutoGen vs LangGraph

AutoGen started from conversation: agents in a team exchange messages until a termination condition ends the run. LangGraph starts from state: nodes update it and edges decide what runs next. Microsoft's own guide shows where it moved: from a `Team` to a typed, graph-based `Workflow`, which is closer to LangGraph's model ([migration guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/)). AutoGen's `GraphFlow` was an experimental step the same way, with agents as nodes and broadcast messages ([migration guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/)).

| If you need | Lean toward |
|---|---|
| Resume a run after a crash | LangGraph checkpointing ([docs](https://docs.langchain.com/oss/python/langgraph/overview)); AutoGen needs your own save and load |
| A human approving mid-run without risking an unsaveable state | LangGraph [`interrupt`](https://docs.langchain.com/oss/python/langgraph/interrupts); AutoGen's `UserProxyAgent` can block the team ([guide](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/human-in-the-loop.html)) |
| Conversation-style agent teams out of the box | AutoGen Teams, or Agent Framework [group chat orchestration](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/) |
| Security and bug fixes upstream | LangGraph; AutoGen receives none from Microsoft |

## LangChain vs CrewAI

LangGraph is the runtime beneath LangChain agents: the LangChain docs say [LangChain's agents are built on top of LangGraph](https://docs.langchain.com/oss/python/langchain/overview). So "LangChain vs CrewAI" is usually "LangChain's `create_agent` on LangGraph vs CrewAI". CrewAI does not depend on LangChain ([README](https://github.com/crewAIInc/crewAI)). See [LangChain](/learn/langchain-framework) for the layers, and [LlamaIndex vs LangChain](/learn/llamaindex-vs-langchain) for the other common pairing.

## Which to choose

| Your situation | Start with |
|---|---|
| You want to define every step, branch and pause | LangGraph |
| You think in roles and teams and want the framework to run the conversation | CrewAI |
| You have an AutoGen app in production | Keep it only while you plan the move to Microsoft Agent Framework ([migration guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/)) |
| You are starting new in .NET | Microsoft Agent Framework (CrewAI is Python-only and AutoGen is archived) |
| You are on the Microsoft stack in Python | Microsoft Agent Framework ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)) |
| A plain function could do the job | None of these; Microsoft's own guidance is that if you can write a function for the task, [do that instead of using an agent](https://learn.microsoft.com/en-us/agent-framework/overview/) |

This table is a judgement from the docs above, not a benchmark. The docs of each project describe features, not how they perform on your task, so run your own tests on your own data before committing. See [LLM evaluation](/learn/llm-evaluation) and [testing AI agents](/learn/testing-ai-agents).

Microsoft's other long-running framework has the same successor. See [Semantic Kernel](/learn/semantic-kernel-framework). For the OpenAI and Google options, see [OpenAI Agents SDK](/learn/openai-agents-sdk-framework) and [Google ADK](/learn/google-adk-framework). To compare those two with LangGraph, see [Google ADK vs OpenAI Agents SDK vs LangGraph](/learn/google-adk-vs-langgraph-vs-openai-agents-sdk); for Pydantic AI and LangChain, see [Pydantic AI vs LangChain vs LangGraph](/learn/pydantic-ai-vs-langchain-vs-langgraph).

## Tracing any of the three

Whichever you pick, multi-agent runs are hard to debug without traces of each agent step and tool call. For the method, see [agent tracing](/learn/agent-tracing) and [LLM observability](/learn/llm-observability). HoneyHive documents integrations for all three: [LangGraph](https://docs.honeyhive.ai/v2/integrations/langgraph), [CrewAI](https://docs.honeyhive.ai/v2/integrations/crewai) and [AutoGen](https://docs.honeyhive.ai/v2/integrations/autogen).

## FAQ

### Is AutoGen still maintained?

Not by Microsoft. The AutoGen README says the project is archived and that Microsoft is [not providing bug fixes, security fixes, new features, or support](https://github.com/microsoft/autogen). It points new users to Microsoft Agent Framework and existing users to a [migration guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/).

### Which is better, LangGraph or CrewAI?

Neither in general. LangGraph is a [low-level orchestration framework](https://docs.langchain.com/oss/python/langgraph/overview) where you define the graph. CrewAI's docs describe [Flows that manage state and control execution, and Crews of autonomous agents that take tasks from a Flow](https://docs.crewai.com/en/introduction). Choose by how much of the control flow you want to write yourself.

### Is CrewAI built on LangChain?

No. The CrewAI README calls it [a standalone Python framework](https://github.com/crewAIInc/crewAI) with its own primitives for agents, tasks, crews, flows and tools. LangGraph is the runtime under [LangChain](/learn/langchain-framework) agents.

### Are LangGraph, CrewAI and AutoGen free?

All three repositories are open source. [LangGraph](https://github.com/langchain-ai/langgraph) and [CrewAI](https://github.com/crewAIInc/crewAI) are MIT licensed, and AutoGen's README lists MIT for code. You still pay for the model and any hosted services you add.

### What replaces AutoGen?

Microsoft names [Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/overview/) as the successor, built by the AutoGen and Semantic Kernel teams. It reached 1.0 for .NET and Python in [April 2026](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/). See [Semantic Kernel](/learn/semantic-kernel-framework) for the other predecessor.