autogen vs langgraph: a maintained runtime against a framework in maintenance mode

What each one actually is

AutoGen describes itself as a framework for creating multi-agent AI applications that can act autonomously or work alongside humans. Its README states that it is now in maintenance mode, will not receive new features or enhancements, and is community managed going forward, with new users directed to Microsoft Agent Framework. The repository is not archived, but its last push was 2026-04-15, roughly five months before today, so it sits just inside a six-month window; the release history is the clearer signal, with the most recent listed release, python-v0.7.5, dated 2025-09-30. LangGraph calls itself a low-level orchestration framework for building, managing and deploying long-running, stateful agents. Its last push was 2026-09-20, and the most recent listed release, sdk==0.4.4, is dated 2026-08-27. The practical difference is not multi-agent versus single-agent. AutoGen ships opinionated agent classes such as AssistantAgent and an AgentTool wrapper for orchestration, while LangGraph ships a graph runtime and expects you to define nodes, edges and the state that flows between them. One hands you agents; the other hands you a runtime for whatever you build on top.

Architecture: layered agents against a graph runtime

AutoGen's README describes a layered and extensible design, with layers that have clearly divided responsibilities and build on the layers below, so you can work at different levels of abstraction from high-level APIs downward. The Core API is event-driven message passing, and the README notes cross-language .NET support. In the quickstart, an AssistantAgent is constructed with an OpenAIChatCompletionClient and run with a single call; multi-agent orchestration is assembled by wrapping one agent as a tool for another through AgentTool. LangGraph inverts this. The runtime is a graph: you declare state, nodes and transitions, and the framework executes them, which is what makes durable execution and interrupts possible at defined points. The README says the public interface draws inspiration from NetworkX and that the design is inspired by Pregel and Apache Beam. That lineage explains the shape of the API: it is closer to a workflow engine than to an agent library. AutoGen's abstraction is an agent that talks; LangGraph's abstraction is a state machine that persists. If you want to describe behaviour as a conversation between roles, AutoGen matches that mental model. If you want to describe it as a directed graph with checkpoints, LangGraph does.

Getting each one running

AutoGen requires Python 3.10 or later. The framework install is pip install -U "autogen-agentchat" "autogen-ext[openai]", with autogenstudio as a separate install for the no-code GUI. The quickstart samples call the OpenAI API, so an OPENAI_API_KEY must be exported first. The README warns that only trusted MCP servers should be connected, because they may execute commands in your local environment or expose sensitive information. It also states plainly that AutoGen Studio is meant to help you rapidly prototype and is not meant to be a production-ready app; developers are told to build their own applications with authentication and security. LangGraph installs with pip install -U langgraph, and an equivalent JS/TS library, LangGraph.js, exists for JavaScript and TypeScript developers. The README points readers who want a batteries-included agent that plans and manages subagents at Deep Agents, a higher-level package built on LangGraph, rather than at LangGraph itself. That is the honest split: LangGraph alone gives you the runtime and leaves planning, subagents and file-system use to packages above it. For a first run, AutoGen gets you to a working assistant with less design work, because the agent abstraction is already there. LangGraph gets you to a working graph node with more design work, because the state schema is yours to write.

Operations, persistence and scale

LangGraph's README lists durable execution, human-in-the-loop, comprehensive memory, debugging with LangSmith and production-ready deployment as the reasons to use it. Those capabilities are not free. Durable execution means the runtime persists through failures and resumes from where it left off, which requires a checkpointer backend; the README does not name a default, so the choice of backend is a deployment decision you have to make and verify in the docs. Human-in-the-loop works by inspecting and modifying agent state at any point during execution, which is only meaningful if that state is persisted. Long-term memory across sessions adds another storage concern. LangGraph can run standalone, but the README also presents LangSmith Deployment as the path for scaling stateful, long-running workflows, and LangSmith for tracing and evaluation. So the operational question is binary: run the runtime on your own infrastructure, or use the hosted deployment path. AutoGen's operational story is thinner in the README. The layered design and event-driven Core API are documented, but the README does not document rollback, a deployment platform or a persistence layer. AutoGen Studio is explicitly framed as a prototyping tool, not a production app. For a team planning uptime and recovery, that asymmetry matters more than any feature list.

Where each one falls short

AutoGen's central limitation is stated by its own README: maintenance mode, no new features or enhancements, community managed, with new users directed to Microsoft Agent Framework. The README names Microsoft Agent Framework as the enterprise-ready successor with stable APIs and a long-term support commitment, and points existing users at a migration guide. That means any new investment in AutoGen is investment in a codebase that will not gain features. The layered architecture and Core API remain usable, and the README says existing users can continue with the architecture described, but you are building on a frozen surface. LangGraph's limitation is the opposite: it is deliberately low level. The README does not present it as a batteries-included agent framework, and it redirects that audience to Deep Agents. You define the state, the nodes and the edges, and you choose the checkpointer backend. That control is the product, and it is also the cost. Teams expecting an agent that plans and manages subagents out of the box will find LangGraph gives them primitives instead. Neither README documents rollback behaviour, so if rollback matters to your deployment, that is a question for the documentation of your chosen deployment path, not for these pages.

Licence and what the push dates imply

AutoGen is licensed CC-BY-4.0. That is a content licence, not a software licence, and it is unusual for a framework you install and run; if your organisation has a policy on licence classes, this is a point to check with counsel rather than assume. LangGraph is licensed MIT, a permissive software licence that most legal reviews already have an opinion on. On maintenance, the facts are unambiguous enough to act on. AutoGen's last push was 2026-04-15 and its README declares maintenance mode; it is not archived, but it is not gaining features. LangGraph's last push was 2026-09-20, and its release history shows sdk==0.4.4 on 2026-08-27, so the project is being pushed to currently. The stars shown in the table are not evidence of quality in either direction; they are a rough measure of attention, and AutoGen's larger count reflects a longer history and a research pedigree the README itself describes. For a new build, the licence and the maintenance signal point the same way: LangGraph is the lower-risk dependency. For an existing AutoGen deployment, the licence question is already settled by the fact that you are running it, and the maintenance question is answered by the migration guide.

Which one for which situation

If you have AutoGen v0.2 or v0.4 code in production, the realistic choice is to keep it running on the version you pinned and plan a migration, because the README states that v0.2 code does not run unchanged and provides a migration guide. If you are starting fresh and want multi-agent orchestration with Microsoft's backing, the README points you at Microsoft Agent Framework, not at AutoGen. If you want to study event-driven message passing or need cross-language .NET support in an agent framework, AutoGen's Core API is still readable and installable, but treat it as a reference implementation rather than a foundation. Choose LangGraph when the hard part of your problem is state: a workflow that runs for hours, branches, pauses for a human, and must resume after a failure. Choose it when you are comfortable writing the state schema and selecting a checkpointer backend, and when you have decided whether you will deploy on your own infrastructure or through LangSmith Deployment. Do not choose LangGraph expecting an agent that plans and manages subagents by itself; the README directs that need to Deep Agents. The two projects are not direct competitors in their current state. One is a maintained runtime for stateful orchestration; the other is a multi-agent framework that has been placed in maintenance mode.

Bottom line

For new work, pick LangGraph unless your problem is specifically multi-agent orchestration with Microsoft tooling, in which case the README's own advice is Microsoft Agent Framework, not AutoGen. Pick AutoGen only to keep existing code alive or to study its Core API. Before committing to either, verify three things: for AutoGen, which package you need and whether your pinned release matches the stable AgentChat docs; for LangGraph, which checkpointer backend your deployment will use and whether you are running on your own infrastructure or on LangSmith Deployment. The decisive fact is that AutoGen's README declares maintenance mode while LangGraph was last pushed on 2026-09-20, so a new dependency should be LangGraph.

Sources

1. microsoft/autogen repository
2. microsoft/autogen README
3. langchain-ai/langgraph repository
4. langchain-ai/langgraph README