AutoGen: Multi-Agent Messaging, Tool Execution, State, and Human Approval

Before covering how AutoGen works, the fact that changes the calculus for anyone evaluating it in September 2026: Microsoft has moved it to maintenance mode, and its own successor already has a 1.0 general release.

........

• AutoGen models multi-agent systems as conversations: agents exchange natural-language messages, and the conversation history itself is the state — a different foundation from LangGraph's state machine or CrewAI's role-and-task model.

• Microsoft released Microsoft Agent Framework (MAF) in public preview in October 2025, integrating both AutoGen and Semantic Kernel, and reached general availability for version 1.0 on April 3, 2026.

• AutoGen's own directory listing in 2026 describes it plainly as being in maintenance mode — still useful for existing users and research, but not recommended as the foundation for a new multi-year platform.

• Two incompatible APIs coexist under the AutoGen name: 0.2.x (the original, now in maintenance) and 0.4's AgentChat API (a full async-first rewrite) — a real source of confusion, since older tutorials online target an API that's since changed underneath them.

• Code execution in a sandboxed container, tool registration through register_function, and human-in-the-loop via a UserProxyAgent's human_input_mode are AutoGen's most-cited strengths, and all three carried forward into Microsoft Agent Framework rather than disappearing.

··········

THE LIFECYCLE STATUS, FIRST.

Anyone evaluating AutoGen for a new project needs this before anything about its architecture.

Microsoft Research announced AutoGen in 2023, and it developed for two years alongside a separate Microsoft framework, Semantic Kernel, which handled enterprise-grade LLM integration through a plugin architecture. The two had different design philosophies and ran in parallel rather than converging.

That changed in October 2025, when Microsoft released a public preview of Microsoft Agent Framework — a unification of both AutoGen and Semantic Kernel into one SDK. MAF reached general availability as version 1.0 on April 3, 2026.

A 2026 framework directory entry states the practical consequence directly: AutoGen's main limitation now is lifecycle risk. It remains useful for existing users, research history, and migration reference, but it isn't the recommended foundation for a new multi-year platform, given that its own successor already has a stable 1.0 release carrying its core ideas forward.

··········

THE CONVERSATIONAL MODEL: STATE IS THE MESSAGE HISTORY.

AutoGen's foundational design choice is treating multi-agent coordination as dialogue rather than as a graph or a task list.

Agents communicate through natural-language messages, and multi-step workflows emerge from agents taking turns — the conversation history is the state, rather than a separate typed object a developer defines up front.

That has a genuine advantage: the conversational paradigm handles ambiguity naturally. When one agent is unsure about something, it asks another agent for clarification, in plain language, the way a human collaborator would.

It also has a genuine cost, named consistently across reviews: conversational execution is harder to make deterministic and auditable than an explicit state machine, and agent conversations can loop or stall without carefully designed termination conditions.

··········

THE CORE AGENT TYPES.

Two agent roles cover most of what a basic AutoGen workflow needs, with a group-chat layer for anything larger.

AssistantAgent is the model-backed participant — it holds a system message defining its behavior and generates responses, including proposing code or tool calls.

UserProxyAgent represents the human or the execution environment in the conversation. Its human_input_mode setting controls how much of a human is actually in that loop: NEVER for fully automated runs, ALWAYS for approval at every step, or TERMINATE for approval only at the end of a run.

RoundRobinGroupChat and other group-chat orchestration patterns let more than two agents share a single conversation with a configurable speaking order, which is how AutoGen scales from a two-agent dialogue to a coordinated team.

··········

TOOL EXECUTION AND CODE SANDBOXING.

AutoGen treats writing and running code as a native capability of the conversation, not a bolted-on plugin.

Functions get registered with register_function, after which an assistant agent describes the available functions in its system message and calls them using standard function-calling format; a user proxy agent executes the function and returns the result back into the conversation. Async functions are supported for non-blocking calls.

Code execution specifically runs in a sandboxed container — commonly Docker — which lets an agent write a solution, execute it, read the actual output or error, and iterate, rather than only reasoning about code in the abstract.

That write-test-iterate loop, with a second agent reviewing the first's output, is the pattern AutoGen's conversational model maps onto most naturally: a coding agent proposes a solution, a reviewer agent critiques it, and the cycle continues until the reviewer is satisfied or a termination condition fires.

··········

AutoGen core agent types

Component	Role	Key setting
AssistantAgent	Model-backed participant, proposes solutions/tool calls	system_message
UserProxyAgent	Represents human or execution environment	human_input_mode (NEVER/ALWAYS/TERMINATE)
register_function	Exposes a Python function as a callable tool	Async supported
RoundRobinGroupChat	Multi-agent shared conversation	termination_condition

··········

HUMAN-IN-THE-LOOP AS A NATIVE PARTICIPANT.

AutoGen's framing of human oversight differs from an external approval gate bolted onto an otherwise autonomous pipeline.

A UserProxyAgent can be configured to request human approval before executing code, at decision points that matter, or at regular intervals — human_input_mode is the lever that decides how often that happens.

Reviews describe this as human-in-the-loop as a first-class participant: a human joins the agent conversation the way another agent would, rather than sitting outside the system as a separate review step layered on afterward.

··········

VERSIONING: TWO APIs UNDER ONE NAME.

A specific, practical source of confusion for anyone starting fresh: AutoGen's documentation and tutorials span two structurally different versions.

Version 0.2.x is the original synchronous conversation-loop design, now in maintenance. Version 0.4 introduced a full async-first, event-driven rewrite, branded AgentChat as its current API — a community fork of the pre-rewrite lineage also circulates under the name AG2.

The practical guidance for 2026: start with the 0.4 AgentChat API specifically, since it's the forward-looking interface — a meaningful share of AutoGen tutorials and examples online still target the older 0.2.x API and will show outdated patterns if followed directly.

··········

HOW AUTOGEN COMPARES TO LANGGRAPH AND CREWAI.

Three frameworks, three different starting assumptions about what a multi-agent system fundamentally is.

LangGraph builds workflows as explicit state machines, with state, branching, and transitions all defined and inspectable by the developer.

CrewAI assigns roles and tasks to agents and lets its own orchestration layer manage coordination, closer to organizing a human team than programming a graph.

AutoGen models everything as conversation — agents talk, and multi-step behavior emerges from that dialogue rather than from a predefined execution graph or task list.

The fit each one earns follows from that difference: teams experimenting with conversational multi-agent patterns, or building iterative workflows like code generation paired with review, tend toward AutoGen's dialogue model. Teams that need deterministic execution order, explicit state management, or reliable, auditable branching logic are steered toward LangGraph specifically, precisely because conversation-as-state is harder to make deterministic by construction.

··········

WHAT TO ACTUALLY DO WITH THIS IN 2026.

The technical strengths described above are all real — the open question is which codebase should carry them going forward.

For an existing AutoGen deployment, the current guidance is to keep it running and plan a migration path rather than treating it as a dead end: Microsoft Agent Framework explicitly carries forward AutoGen's human-in-the-loop patterns, orchestration concepts, and general design lineage into a production-oriented, GA-stable target.

For a new multi-agent project starting from nothing in September 2026, evaluating Microsoft Agent Framework directly — rather than starting fresh on AutoGen — avoids building on a codebase whose own maintainer has already named its successor.

Where AutoGen's ideas remain genuinely worth studying regardless of which SDK ends up running in production: the conversational coordination model, the code-execution sandbox pattern, and treating human approval as a native conversational participant rather than an external gate are all patterns other frameworks have since converged toward, AutoGen having explored them first.

··········

·····

FOLLOW US FOR MORE.

·····

·····

DATA STUDIOS

·····

datastudios.org