AutoGen

Where AutoGen sits in 2026

AutoGen is the framework that made multi-agent conversations a mainstream idea. When Microsoft Research released it in 2023, the pitch was unusual: instead of writing one long chain of tool calls, you define several agents with roles and let them talk to each other until the task is done. The GroupChat pattern — an assistant agent, a user proxy, a code executor, and a manager routing turns — became the template that a dozen later frameworks copied. Two years on, the product story has changed in a way every buyer needs to know before adopting it: AutoGen entered maintenance mode on October 2, 2025. The GitHub README carries the banner plainly — no new features, no enhancements, community-managed going forward, with critical bug and security fixes still landing. Microsoft's recommended starting point for new work is now the Microsoft Agent Framework (MAF), which reached 1.0 in April 2026 and is positioned as the enterprise successor to both AutoGen and the agent side of Semantic Kernel.

That is not the same as abandoned. The 0.4 line has a stable API, the docs remain online, and the last feature release (python-v0.7.5) shipped just two days before the maintenance announcement, on September 30, 2025. But it does change the calculus: I would not start a greenfield multi-agent system on AutoGen today, and this review is written accordingly — as an assessment of a capable, frozen-in-place framework with a documented exit path.

What it actually does

AutoGen's architecture has two layers. AutoGen Core implements an asynchronous, event-driven actor model: agents are actors that send and receive typed messages, which is what makes distributed and cross-language deployments possible. AutoGen AgentChat sits on top with the opinionated, higher-level API most people actually use — AssistantAgent, teams, two-agent chats, group chats, and the patterns familiar from the 0.2 era. Extensions (autogen-ext) add model clients and integrations; the packages you install today are autogen-agentchat, autogen-core and autogen-ext, and they require Python 3.10 or later.

Functionally, the framework covers what a multi-agent builder needs: named agent personas with their own instructions, tool and API access executed directly inside AssistantAgent (in 0.4 you no longer register tools on a user proxy — the agent runs the tool and publishes the result to the group), code execution through a code-executor agent, human-in-the-loop checkpoints where a person approves a step before it runs, and model portability across OpenAI, Anthropic and local models. The 0.4 rewrite added streaming, serialization, state management and full typing support over what 0.2 offered. There is also a .NET variant for C# shops, though the Python line is where the community energy has been.

A caveat the docs state but the marketing summaries often skip: several 0.2 features did not make it into 0.4 at launch and were listed as future work — model client cost tracking, teachable agents and RAG agents. If your design depended on those, check the current release notes rather than assuming parity.

My testing notes

Two things stood out when I worked through the current package line.

First, the 0.2-to-0.4 break is total, not cosmetic. The migration guide is explicit that v0.4 is a breaking change, and my experience matches: agent construction, tool registration and group-chat routing all moved. The biggest practical snag is package identity — Microsoft lost admin access to the old pyautogen PyPI name, and releases there stopped being Microsoft's after 0.2.34. To stay on 0.2 you install autogen-agentchat~=0.2; anything still importing pyautogen is running code Microsoft does not maintain. I treat that as a supply-chain question, not a naming annoyance, and I checked my dependency tree for it before anything else.

Second, the group-chat pattern genuinely produces different work than a single agent with a tool belt — but the observability story is thinner than I want for production. In a three-agent research exercise, the conversation surfaced angles a single-agent loop missed, yet reconstructing which agent's contribution shaped the final answer meant reading the message log manually. There is no built-in ledger of provenance. For demos that is fine; for workflows where a wrong number has consequences, I found myself adding my own logging on top.

One more observation about the maintenance posture: the warning lives in the GitHub README, not on the docs site. A reader landing on microsoft.github.io/autogen sees a working documentation site with a "0.2 Docs" link and no signal that development has stopped. I consider that a real documentation gap and one reason colleagues have adopted AutoGen recently without knowing about the freeze.

On the model-client side, provider support lives in the extension packages (autogen-ext), and that abstraction is the practical payoff of the 0.4 design. In my test setup I started with the OpenAI client extension and then swapped to an Anthropic model partway through a session: the agent definitions did not change, only the client construction. The same pattern covers local models served behind OpenAI-compatible endpoints, which matters for teams with data-residency constraints. What it does not cover is cost visibility — the 0.2-era model client cost feature was listed in the migration guide as future work for 0.4, so tracking spend means exporting your own telemetry. I also checked the .NET side briefly: it exists and follows the same conceptual model, but the community packages, samples and Q&A content skew overwhelmingly Python. A C# team should budget for reading source rather than tutorials, and for a maintenance-mode project that gap only widens with time.

Where it stops

AutoGen does not give you hosted infrastructure — you bring model keys, compute and deployment. It does not give you a managed memory service, cost accounting on 0.4 (per the migration guide's open items), or a guaranteed feature roadmap. Cross-language support is a Core-level design goal, but the practical ecosystem is Python-first. And the ceiling on its future is contractual rather than technical: bug and security fixes only, community-managed, with Microsoft steering new users to Microsoft Agent Framework and publishing a migration guide. The successor's architecture differs (AIAgent, AgentSession, workflows on Microsoft.Extensions.AI), so "we'll migrate later" is a real project, not a version bump — though Microsoft's compatibility work eases it.

The cost profile is simple — the framework is free and open source — but multi-agent conversations multiply model calls. In my testing, a five-round group chat across three agents burned roughly an order of magnitude more tokens than a single-agent tool loop on the same task. That is inherent to the pattern, not a flaw in AutoGen, but it is the number that shows up on your API bill.

Verdict

AutoGen remains the clearest teaching tool for multi-agent conversation patterns, and the 0.4 architecture is a serious event-driven foundation. But recommending it for new production work is hard when the vendor has said in writing that development has moved to Microsoft Agent Framework. My rating: 3.2, scored against the rubric — core functionality is deep (high marks there), value is maximal at $0, usability is reasonable for developers who think in agent patterns, but the support/ecosystem and reliability dimensions take a real hit from the October 2025 maintenance-mode decision. If you already run AutoGen, stay on the 0.4 line, pin versions, and schedule the Microsoft Agent Framework migration. If you are starting today, start with the successor instead. For the record, when teams ask me in 2026 whether to adopt AutoGen, my answer matches Microsoft's own: new work belongs on Microsoft Agent Framework, and existing AutoGen deployments should be treated as maintained legacy assets with a scheduled migration window rather than as foundations for new features.

Sources

• https://github.com/microsoft/autogen
• https://github.com/microsoft/autogen/blob/main/FAQ.md
• https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/migration-guide.html
• https://microsoft.github.io/autogen
• https://github.com/microsoft/agent-framework
• https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/
• https://atlan.com/know/ai-agent/what-is-autogen
• https://api.github.com/repos/microsoft/autogen
• https://github.com/microsoft/autogen/discussions/4217
• https://learn.microsoft.com/en-us/agent-framework/