A8gent
AI Agent PlatformsDeveloper framework

Microsoft AutoGen Review: Maintenance Mode (2026)

A framework for multi-agent conversations and workflows.

Reviewed by A8gent
Contents
  1. Verdict
  2. What is Microsoft AutoGen?
  3. Best for, and not for
  4. Strengths and limits
  5. Pricing
  6. What people actually build with it
  7. What AutoGen actually costs at small-business volume
  8. The gotcha: the real cost is now the roadmap, not the tokens
  9. What breaks in production, and how you find out
  10. What it connects to that you already run
  11. AutoGen alternatives: what to pick instead, and when
  12. Migration and lock-in: can you get your work out?
  13. FAQ
VerdictIs Microsoft AutoGen worth it?

AutoGen is in maintenance mode and you should not start a new project on it. Microsoft's own README states plainly that it "will not receive new features or enhancements and is community managed going forward", and directs new users to Microsoft Agent Framework, which it calls "the enterprise-ready successor to AutoGen". The repository still shows 60,254 stars, but the last commit we saw was 15 April 2026, nearly four months before we checked. AutoGen's ideas were genuinely influential and its conversational multi-agent system remains an excellent research tool. As a foundation for a business process you intend to run in 2027, it is the wrong choice, and Microsoft is the one telling you so.

What is Microsoft AutoGen?

AutoGen is an open-source framework from Microsoft Research for building applications with multiple agents that converse and collaborate to complete tasks. Its recent versions use a layered, event-driven, asynchronous architecture, and it ships with AutoGen Studio, a low-code interface for prototyping agent teams without writing much code. It supports agents that use tools, execute code, and involve a human in the loop.

Best for

Researchers and developers experimenting with multi-agent conversation patterns and code-executing agents.

Not for

Any new project, full stop. Microsoft has put AutoGen in maintenance mode and points new users at Agent Framework, so starting here in 2026 means starting on something the vendor has already replaced.

Strengths

  • Free and open source under a permissive licence, with 60,254 stars and a large body of published multi-agent patterns that remain useful reading
  • The conversational multi-agent model is genuinely good at exploratory problems where the approach is not known in advance
  • Human-in-the-loop participation is native, so a person can be one of the conversing agents rather than an afterthought
  • Code execution lets agents write and run code to solve analysis problems, which is powerful when properly sandboxed
  • Model-agnostic, so cheap models can play routine roles while a stronger one handles the hard reasoning
  • The successor is built by the same people: Microsoft's migration guide states Agent Framework is developed by the core AutoGen and Semantic Kernel teams, so the ideas carry forward even though the code does not
  • Community managed going forward, so the code will not vanish and existing deployments keep working

Limitations

  • In maintenance mode: Microsoft's README states it will receive no new features or enhancements and is community managed
  • The last commit we observed was 15 April 2026, nearly four months before we checked on 6 August 2026, against 977 open issues
  • Microsoft's successor abandoned the conversational group-chat centrepiece in favour of typed data-flow workflows, so the pattern you would learn here is the one they moved away from
  • Token consumption per outcome is genuinely unpredictable, because conversation length is emergent rather than specified
  • Agents can converse at length without converging, which is expensive and produces nothing
  • Code execution by agents is a real security exposure and needs proper sandboxing rather than good intentions
  • Research heritage means tooling for production concerns such as monitoring, retries and deployment is thin

Microsoft AutoGen pricing

AutoGen is free open-source software and always was, so maintenance mode changes nothing about the bill: your costs are model tokens from whichever provider you point it at, plus hosting. There is no platform fee or execution meter. The cost characteristic specific to AutoGen is conversational. Agents converse to reach a solution and the number of turns is emergent rather than specified, so token consumption per outcome varies far more than in a fixed-sequence workflow and two runs of the same task can differ several-fold. What maintenance mode adds is a second, non-monetary cost: engineering time spent on a framework that will not gain features, against a successor that will.

Microsoft AutoGen pricing tiers
PlanPriceWhat you get
Framework$0Free open-source software; no platform fee, seats or execution meter. In maintenance mode as of August 2026
Model tokensProvider ratesBilled by whichever provider you use; conversational multi-agent runs consume several times more per outcome than a single agent
Hosting~$5-$20/moA small server or container to run the agents
Cost warningHighly variableTurn counts are emergent rather than specified, so two runs of the same task can differ several-fold in token consumption
Migration costEngineering timeMoving to Microsoft Agent Framework is a rewrite of the orchestration layer, not a package rename. Microsoft publishes a migration guide

Pricing reflects public plans as of August 6, 2026 and can change. Check Microsoft AutoGen for the latest.

What people actually build with it

Read this section as history plus salvage. AutoGen is in maintenance mode, so the question is no longer what to build with it but which of its patterns are worth carrying to whatever you build instead.

The patterns worth keeping

Research and synthesis is where the conversational model genuinely earned its reputation. A researcher agent gathers material on a supplier or a market, a critic agent challenges the weak claims, and the loop continues until the critic stops objecting. The output really is better than a single pass, because the critique is a separate act of reasoning rather than the same model checking itself in the same breath. Businesses used this for competitor briefs, due-diligence summaries and technical option papers. It is also the pattern that consumes the most tokens, for exactly the reason it works: the disagreement is the product.

Data analysis with code execution is the second. An agent receives a spreadsheet of monthly sales, writes Python to load it, discovers the date column is text, writes more Python to fix it, plots the trend and explains what it sees. Nothing declarative handles that gracefully, because the errors are not knowable in advance. For an accounting firm reconciling messy client exports it is genuinely valuable, and it demands a sandboxed container with no credentials and no network route to anything that matters.

Writer-editor pipelines were the third common shape. A writer agent drafts against a brief, an editor agent revises against a style guide, and a human approves. In practice most teams found the improvement plateaus after two rounds while the token bill does not, which is why turn limits matter more here than anywhere else.

The pattern to leave behind

The shape AutoGen made famous, and the one to abandon, is routing a defined business process through a group chat. Invoice approval, ticket triage and onboarding sequences all have known steps, and letting three agents discuss which step comes next costs perhaps ten times the tokens and fails in ways you cannot reproduce.

Microsoft reached the same conclusion. Agent Framework's headline abstraction is a typed workflow with executors and edges, not a group chat, and the migration guide describes it as data-flow routing where executors activate when their inputs are ready. When a framework's own authors replace conversation with a graph, that is the strongest available evidence about which pattern belongs in production. If your process is a flowchart, build it in something that draws flowcharts, whether that is LangGraph in code or n8n on a canvas.

Bottom line: AutoGen's critic-and-writer research loops and code-executing analysis agents are worth carrying forward; routing a defined business process through an agent group chat is the pattern Microsoft itself replaced with typed workflows.

What AutoGen actually costs at small-business volume

The framework is free and there is no meter, so the only figures are tokens and hosting. What makes AutoGen different from every other free framework here is that you cannot compute the token figure from the workload alone, because the workload does not determine how many model calls happen. The conversation does.

Start from the reference workload: 1,000 inbox triage items a month at roughly 3,000 input and 400 output tokens each. As a single agent making one call per item, that is 3 million input and 400,000 output tokens. Now run the same item as a three-agent conversation taking eight turns to converge. Each turn is a model call carrying everything said so far, so the input grows turn over turn.

Single agent versus an illustrative three-agent, eight-turn conversation over the same 1,000 items. Turn count is illustrative, not a benchmark we ran. Rates from OpenAI's pricing page, 6 Aug 2026.
DesignModel calls per itemInput tokens / monthOutput tokens / monthCost on gpt-4o-mini
Single agent, one call13.0M0.40M~$0.69
Single agent, 3 tool calls4~7M to 12M~1.6M~$1.50 to $2.80
Three agents, 8 turns8~35M~3.2M~$7.20
Three agents, 20 turns20~136M~8M~$25

Why the multiplier is a range, not a number

We want to be precise about the status of those figures. The turn counts are illustrative configurations, not measurements. Your real conversation could converge in four turns or wander to twenty, and the whole point is that you do not get to choose. The growth pattern, though, is structural rather than incidental: turns multiply calls, and accumulated context makes each call dearer than the last. That is why the multiplier is large and why it has to be expressed as a range.

The consequence for budgeting is the point. A single-agent design lets you write a number in a spreadsheet with reasonable confidence. A conversational one does not, because the same task can converge in three turns on Monday and fifteen on Tuesday depending on what the model happened to say first. If your business needs a line item that looks similar every month, this architecture is fighting you.

The three controls if you run it anyway

A maximum turn limit on every conversation, so non-convergence terminates rather than continues. Model tiering, so routine participants use a cheap model and only the hard reasoning role uses an expensive one; AutoGen being model-agnostic makes this genuinely easy, and mixing Gemini or an open-weight model into the cheap seats is legitimate. And a hard spend cap at the provider, because a limit that stops billing beats an alert that describes it.

Bottom line: Running the reference 1,000-item workload as an illustrative three-agent, eight-turn conversation costs roughly ten times the single-agent token bill, about $7.20 against $0.69 on gpt-4o-mini, and the multiplier is a range because turn counts are emergent.

The gotcha: the real cost is now the roadmap, not the tokens

Everything above was true a year ago and remains true. The gotcha that changed in 2026 is different in kind, and it is why we rewrote this page. AutoGen is free, and its price is now paid in engineering time on a framework that has stopped moving.

Microsoft's README states it plainly: AutoGen "is now in maintenance mode. It will not receive new features or enhancements and is community managed going forward." The repository data supports the statement rather than contradicting it. On 6 August 2026 the GitHub API showed 60,254 stars, 977 open issues and a last push of 15 April 2026, nearly four months earlier. Sixty thousand stars measures how influential the project was, not whether anyone is working on it, and that is exactly the trap star counts set for anyone evaluating a framework quickly.

The cost lands in three places. New model capabilities need community patches or your own. Security and dependency updates arrive on community time rather than Microsoft time. And a future migration is now a certainty you have deferred rather than a risk you have avoided, so the question is when you pay it, not whether.

This is the vendor-backed open-source bargain showing its teeth. The framework was free, well engineered and genuinely influential, and none of that gave the community a vote when the sponsor reorganised. Anyone betting a business process on vendor-backed open source should price this in as a real possibility rather than a tail risk, and should read the total cost of ownership as including one unplanned migration.

Bottom line: AutoGen's real 2026 cost is not tokens but a deferred migration: Microsoft's README puts it in maintenance mode, and the repository had gone unpushed since 15 April 2026 when we checked on 6 August 2026.

What breaks in production, and how you find out

Non-convergence is the characteristic failure and it is worse than an error, because it looks like work. Agents discuss, refine and rephrase without reaching a conclusion, tokens accumulate, and nothing is produced. There is no exception, no alert and no red dashboard, only a provider bill higher than last month. Set a maximum turn limit on every conversation and log the runs that hit it, because the count of terminated conversations is the health metric that actually predicts your spend.

Cost variance is a trust problem, not a technical one

A process that cost forty dollars in March costs a hundred and ten in April with no change to the code, because the conversations went longer. Nothing is broken. The architecture simply does not promise repeatability, and the finance conversation about that is harder than the engineering one. Track tokens per completed outcome as a running distribution rather than a single average, because the tail is what surprises you, and quote a range rather than a figure when someone asks what it costs to run.

Code execution and the sandbox you must not skip

An agent that writes and runs code on a machine holding your credentials is an exposure regardless of intent, and a confused agent fed a poisoned document behaves much like an attacker. This is prompt injection with a shell attached. Isolated container, no credentials it does not strictly need, no network route to anything sensitive. Treat it as code submitted by an untrusted user, because functionally that is what it is.

Version churn now runs in reverse

The AutoGen API changed substantially across versions, most notably between v0.2 and v0.4, which is why Microsoft points v0.2 users at a migration guide of their own. Going forward the risk inverts: instead of breaking changes arriving, nothing arrives, and the friction becomes an unpatched dependency or a new model your version does not support. Pin your versions, and put a quarterly reminder to check the repository's push date, because a project in maintenance mode gives no other signal.

Underneath all of it sit the ordinary agent failures: silent stoppage nobody notices for a fortnight, tool arguments that are plausible and wrong and get accepted downstream, and no monitoring except what you built. AutoGen's research heritage means production tooling is thin, so assume you are writing the heartbeat, the retry and backoff logic and the alerting yourself.

Bottom line: AutoGen's signature production failure is non-convergence, where agents keep talking without producing anything, so a maximum turn limit on every conversation plus tracking of terminated runs is the minimum viable control.

What it connects to that you already run

AutoGen is model-agnostic and business-system-agnostic, which is a polite way of saying there is no connector catalogue. Every system you want an agent to touch is a Python function you write against that system's API and register as a tool the agents can call during a conversation.

On the model side the flexibility is real and useful. You can point different agents in the same conversation at different model providers, which is the single most effective cost control available here: a cheap model for participants that summarise and relay, a stronger one for the role that has to reason. Azure OpenAI works as naturally as the direct OpenAI API, which was always part of the appeal for organisations wanting the model inside an existing Azure agreement rather than a new vendor relationship.

The code execution capability doubles as an integration route, and a double-edged one. An agent that can write and run Python can in principle call any API you hold credentials for without you building a tool. That is genuinely flexible and precisely what the sandbox exists to contain, so the useful version is a sandboxed environment with a small, deliberately chosen credential set rather than a machine that can reach everything.

The realistic pattern for a smaller team is the same as with any SDK: let the agents reason and hand the structured result to an automation layer that already holds the connectors, so the CRM write, the booking and the notification happen somewhere with retries and a log. Given maintenance mode, keep that boundary sharp. The more of your integration logic lives outside AutoGen, the cheaper the eventual migration.

Bottom line: AutoGen has no connector catalogue, so integrations are tool functions you write, and keeping them outside the framework is now a migration strategy rather than just good hygiene.

AutoGen alternatives: what to pick instead, and when

Because AutoGen is in maintenance mode, this is not an optional comparison section. It is the recommendation. Everything below is free at the framework layer, so the table separates them on shape, language and roadmap rather than licence cost.

Where to go instead of AutoGen. Costs are the same token arithmetic in every row, because none of these frameworks add a meter. Checked 6 Aug 2026.
OptionBilling unitCost at reference workloadWho it suitsThe one thing it does better
AutoGenModel tokens only~$7 or more, highly variableResearch and exploration onlyConversational multi-agent exploration of an unknown approach
Microsoft Agent FrameworkModel tokens onlySame tokens plus hostingMicrosoft shops, Python or .NETThe supported successor, with typed workflows and stable APIs
Semantic KernelModel tokens onlySame tokens; often no extra hosting.NET teams with an existing applicationFirst-class C# and Java, though also being consolidated
LangGraphModel tokens; LangSmith priced separately~$0.31 to $27 plus optional tracingUnattended processes needing repeatabilityExplicit graph control flow with checkpoints and approval gates
CrewAIModel tokens onlyHigher than single-agent, lower than group chatRole-based agent teams with defined responsibilitiesMulti-agent structure without emergent turn counts
AutonolyQuoted per build, no per-seat licenceQuoted after a free automation auditBusinesses with the process and no developerA running, documented workflow you own rather than a library

When to pick the alternative

Pick Microsoft Agent Framework if you are staying in the Microsoft world. It is the vendor's own answer, it supports Python and .NET, and Microsoft publishes a migration guide from AutoGen specifically. Note the same guide says it is built by the core AutoGen and Semantic Kernel teams, which is the tell that Semantic Kernel is on the same consolidation path, so treat the two as one decision rather than two.

Pick LangGraph if you are Python-first and not committed to Microsoft. It is the closest thing to what AutoGen's successor became, arrived at independently, and its explicit graph gives you the checkpoints, approval gates and failure paths that unattended work needs. Pick CrewAI if the multi-agent structure was the appeal and you want roles without emergent turn counts, which keeps most of the expressiveness and returns some cost predictability.

Pick the OpenAI Agents SDK if, on reflection, you never needed multi-agent at all. A large share of AutoGen projects were one agent with several tools wearing a group chat costume, and that version is smaller, cheaper and easier to debug. And pick a done-for-you build if nobody on your side will own a framework migration in eighteen months, because that is exactly the situation AutoGen users are now in.

Bottom line: Move AutoGen work to Microsoft Agent Framework if you are staying with Microsoft, LangGraph if you are Python-first and want explicit control flow, or the OpenAI Agents SDK if the project never genuinely needed multiple agents.

Migration and lock-in: can you get your work out?

Commercially, nothing holds you. AutoGen is permissively licensed open source, your agent definitions and tools are your own Python, and no vendor can raise a price or revoke a plan. In the narrow sense the answer is yes, easily.

The lock-in is architectural, and maintenance mode has converted it from theoretical to scheduled. An application designed around a conversational multi-agent system does not port trivially to a graph framework, because the architecture is genuinely different.

The Microsoft consolidation: what it means if you are starting a project today

Here is the situation in plain terms, as of 6 August 2026. Microsoft ran two agent frameworks, AutoGen out of Microsoft Research and Semantic Kernel out of the product organisation. It has folded both into one successor, Microsoft Agent Framework, which its documentation says is developed by the core AutoGen and Semantic Kernel teams and is a new foundation for building AI applications going forward. The AutoGen README calls it the enterprise-ready successor. Microsoft Learn publishes two migration guides side by side, one from AutoGen and one from Semantic Kernel, which is the clearest possible statement that both are origin points rather than destinations.

If you are starting a project today and you want to be inside Microsoft's ecosystem, start on Agent Framework. Not AutoGen, which the vendor says will receive no new features. Not Semantic Kernel, which has a migration guide pointing away from it. On 6 August 2026 the Agent Framework repository showed 12,622 stars against 663 open issues, created in April 2025 and pushed the previous day, and it supports Python and .NET. It is younger than what it replaces and it is the only one of the three receiving Microsoft's engineering attention.

If you are not committed to Microsoft, the honest reading is that this episode is an argument for choosing a framework whose sponsor cannot reorganise it out from under you. LangGraph and the OpenAI Agents SDK carry their own vendor gravity, but neither has just deprecated its own flagship abstraction. Whatever you choose, keep the business logic in ordinary functions rather than in framework constructs, because that is the part you cannot afford to rewrite twice.

What survives a migration and what does not

Microsoft's own migration guide is candid about the shape of the work. AutoGen pairs an event-driven core with a high-level Team, while Agent Framework centres on a typed graph-based Workflow that routes data along typed edges and activates executors when their inputs are ready. Agent behaviour differs too: AssistantAgent is single-turn unless you raise max_tool_iterations and keeps conversation history as part of its state, while Agent Framework's Agent is multi-turn by default and stateless between invocations. Those are not renames.

Your tool functions survive almost intact, because they are ordinary code calling your systems. Your prompts survive with tuning. Your evaluation cases survive entirely, and if you have them the migration becomes measurable rather than a matter of opinion. What does not survive is the orchestration layer: the teams, the group chats, the selectors and the termination conditions all get rewritten. Keep integrations behind your own interfaces and maintain a set of real cases with known-correct answers, and the move becomes a project with a defined scope and a way to prove it worked.

Bottom line: As of 6 August 2026 AutoGen is in maintenance mode and Semantic Kernel has a migration guide pointing away from it, because Microsoft has consolidated both into Microsoft Agent Framework, so a new Microsoft-stack project should start on Agent Framework and neither of the other two.

Microsoft AutoGen FAQ

Is AutoGen still maintained in 2026?

Not in the sense most people mean. Microsoft's own README states that AutoGen "is now in maintenance mode. It will not receive new features or enhancements and is community managed going forward." When we checked the GitHub API on 6 August 2026 the last push was 15 April 2026, with 977 open issues against 60,254 stars. The code is still there and still works, and the community may keep patching it, but Microsoft's engineering effort has moved to Agent Framework.

What replaced AutoGen?

Microsoft Agent Framework, which the AutoGen README describes as "the enterprise-ready successor to AutoGen" with stable APIs and a commitment to long-term support. Its migration guide says it is developed by the core AutoGen and Semantic Kernel teams, meaning Microsoft consolidated both of its agent frameworks into one. It supports Python and .NET, is open source on GitHub, and Microsoft publishes separate migration guides from AutoGen and from Semantic Kernel. When we checked on 6 August 2026 it had been pushed to the day before.

Should we migrate off AutoGen?

If you are starting something new, do not start here at all. If you already run AutoGen in production there is no emergency: it is open source, community managed, and nothing stops working because Microsoft changed focus. Plan the move rather than rushing it. Budget it as a rewrite of the orchestration layer rather than a package upgrade, because the successor's model is genuinely different, and do it when you next need a substantial change rather than as a standalone project with no user-visible benefit.

How hard is the migration to Agent Framework?

Harder than a rename, easier than starting over. Microsoft's migration guide maps the concepts: AutoGen's event-driven core plus high-level Team becomes a typed graph-based Workflow that routes data along edges and activates executors when their inputs are ready. Agent behaviour differs too, because AutoGen's AssistantAgent is single-turn unless you raise max_tool_iterations while Agent Framework's Agent is multi-turn by default and stateless between invocations. Your tools and prompts carry over largely intact. Your orchestration code does not.

What does AutoGen cost?

The framework is free and open source. Your bill is model tokens plus hosting, and the token figure is the one to watch, because AutoGen's agents talk until they reach a solution and the number of turns emerges from the conversation rather than being specified. Two runs of the same task can differ several-fold. Measure tokens per completed outcome across a representative sample before you plan a budget around it, and set a maximum turn limit on every conversation.

Why is conversational multi-agent so expensive?

Because every turn is a model call carrying the accumulated conversation, and the conversation grows. Take our reference workload of one item at 3,000 input and 400 output tokens. Run that item as a three-agent discussion over eight turns and the arithmetic gives roughly 35,000 input and 3,200 output tokens for the identical outcome, because each turn resends everything said so far. That is around ten times the tokens. The turn count is illustrative rather than measured, but the growth pattern is structural.

Is agent code execution safe?

Only if you sandbox it properly, and this deserves more attention than it usually gets. An agent that can write and execute code on a machine with access to your systems is a serious exposure, and the fact that a model wrote the code rather than an attacker does not make it safe. A confused agent and a malicious prompt produce similar outcomes. Run code execution in an isolated container with no network access to anything sensitive and no credentials it does not strictly need.

AutoGen or Agent Framework or LangGraph?

Not AutoGen, for anything new. Agent Framework if you are a Microsoft shop, especially a .NET one, since it is the consolidated successor to both AutoGen and Semantic Kernel and supports C# properly. LangGraph if you want the larger Python ecosystem and explicit graph control flow with checkpoints and approval gates. Notably, both successors converged on the same answer: typed graphs with specified edges rather than agents chatting until they agree.

Can you tell us whether this is overkill?

Yes, and it very often is. A large share of what gets scoped as multi-agent work turns out to be a defined process with one or two AI steps, which costs a fraction as much and behaves predictably. We work that out on a free automation audit, tell you plainly which it is, and if a build makes sense we do it on something proportionate with a roadmap behind it, then hand it over documented and owned by you, with a recurring plain-language report of what ran and what it cost.

Looking at alternatives? The most useful thing we can tell you about AutoGen in 2026 is that Microsoft has moved on, and the honest advice follows: do not start here. If you already run something on it you are not in trouble, because it is open source, community managed and existing deployments keep working, but budget for a migration rather than assuming one will not be needed. What we would take from AutoGen is the lesson rather than the library. Its successor replaced conversational group chat with typed data-flow workflows, which is the same conclusion we reach on most client work: if you can draw the process as a flowchart, build it as one. Autonoly builds the flowchart version, on something with a roadmap. See the Autonoly review.