Skip to main content

AutoGen Guide (2026) | Build Multi-Agent AI Applications with Microsoft AutoGen

Introduction​

AutoGen is one of the most influential open-source frameworks for building multi-agent AI systems. Originally developed by Microsoft Research, it pioneered the concept of conversational multi-agent collaboration—where specialized AI agents work together like a team, exchanging messages, calling tools, and executing code to solve complex problems.

By 2026, the multi-agent landscape has matured dramatically. The AI agents market hit $10.9 billion in 2026, and Gartner forecasts that 40% of enterprise applications will embed task-specific AI agents by the end of 2026. However, the framework landscape has also consolidated. In October 2025, Microsoft announced that AutoGen would merge with Semantic Kernel to become the unified Microsoft Agent Framework (MAF). AutoGen and Semantic Kernel entered maintenance mode, with MAF reaching version 1.0 and general availability in April 2026.

This guide explains what AutoGen is, why it was created, how its multi-agent conversation architecture works, and how it compares to other frameworks. It also covers the critical context for 2026: AutoGen's legacy, its relationship to MAF, and what it means for developers building production agent systems.

What Is AutoGen?​

AutoGen is an open-source framework for building conversational single-agent and multi-agent LLM applications where agents exchange messages, call tools, execute code, and sometimes involve a human reviewer. It was originally developed by Microsoft Research's AI Frontiers Lab.

The Core Idea​

Instead of relying on one AI model to do everything, AutoGen lets you set up multiple agents, each with its own specialized job, and have them talk to each other to solve problems. One agent handles planning, another writes code, another reviews the code, and another reports back to the user. AutoGen handles all the behind-the-scenes coordination—you just define your agents, describe what each one should do, and let AutoGen manage how they communicate and work together.

Design Philosophy​

AutoGen's philosophy is rooted in how human teams solve complex problems: divide and specialize. Complex tasks get done better when you split them up and give each piece to someone who specializes in it. Agents are "conversation participants"—the whole system is like a group chat, sometimes structured, sometimes free-form. Agents can delegate tasks, critique and correct each other, call tools, write and execute code, ask humans for input, and terminate when a goal is reached.

The 2026 Reality: AutoGen and Microsoft Agent Framework​

A critical piece of context for 2026: AutoGen is no longer under active development as a standalone framework.

In October 2025, Microsoft announced that AutoGen and Semantic Kernel would merge into a unified Microsoft Agent Framework (MAF). Both AutoGen and Semantic Kernel entered maintenance mode—Microsoft continues to fix critical bugs and security issues but no longer adds major new features. MAF reached version 1.0 and general availability in April 2026, stable across .NET and Python.

MAF combines AutoGen's intuitive agent abstractions with Semantic Kernel's enterprise-grade features—including session-based state management, type safety, execution filters, and telemetry. The framework introduces graph-based workflows to give developers explicit control over multi-agent execution paths.

For new projects, the recommended path is Microsoft Agent Framework, not AutoGen. However, understanding AutoGen remains valuable because:

  • Its concepts and patterns live on in MAF
  • Many existing production systems still run on AutoGen
  • The conversational multi-agent paradigm AutoGen pioneered is foundational to modern agentic AI

Why AutoGen Was Created​

The Problem with Single LLM Applications​

Before AutoGen, LLM applications had fundamental limitations:

  • Single-threaded reasoning: One model handles everything, leading to context overload
  • Role conflict: The same model that generates creative ideas must also perform rigorous review
  • Poor task decomposition: Complex multi-step tasks overwhelm a single model
  • Limited tool orchestration: No built-in way for models to collaborate with tools or each other
  • No built-in human oversight: Critical decisions couldn't easily include human approval

How AutoGen Solved These Problems​

AutoGen introduced a completely different mental model: agents as conversation participants in a multi-agent dialogue. Instead of a single chain of prompts, AutoGen enabled:

  • Specialized agents: Each agent has a distinct role (planner, coder, reviewer, executor)
  • Conversational coordination: Agents exchange messages, delegate tasks, and critique each other
  • Tool calling and code execution: Agents can use tools and run code as part of their work
  • Human-in-the-loop: Agents can pause and ask for human input
  • Autonomous termination: Agents stop when the goal is reached

Early viral demos—coder + reviewer + executor teams solving math problems, research groups, stock analysis teams—showed 2–10x performance improvements over single-agent systems on many tasks.

Core Concepts​

Agent​

An agent is the fundamental building block in AutoGen. Agents are composed of generative AI models extended with tools. They observe, reason, plan, act, and use tools like memory for storing learnings or software like web browsers. Agents autonomously accomplish tasks on behalf of humans, collaborate in agent teams, and interact with humans through natural language.

Assistant Agent​

The Assistant Agent is a configurable LLM-powered agent. It generates solutions and code based on the conversation context. It's typically the "brains" of the operation—the agent that does the primary reasoning and generation.

User Proxy Agent​

The User Proxy Agent acts as a proxy for the human user. It can execute code, provide feedback, and manage the interaction between the human and the agent system.

Key configuration options:

  • human_input_mode: NEVER (fully autonomous), ALWAYS (always ask human), or TERMINATE (ask only before termination)
  • max_consecutive_auto_reply: Limits how many times the agent replies without human input
  • code_execution_config: Configures code execution environment

Group Chat​

Group Chat is a conversation pattern where multiple agents participate in a shared chat room, exchanging messages to solve a problem collaboratively. Agents can be added to the group, and a manager determines the turn order or allows free-form conversation.

Conversation​

In AutoGen, conversations are the primary unit of work. Agents communicate by sending messages to each other. The initiate_chat method starts a conversation between two agents.

Tool Calling​

Agents can call tools—external functions that perform specific actions like querying a database, calling an API, or performing a web search.

Code Execution​

AutoGen agents can write and execute code in a sandboxed environment. This enables agents to perform complex data analysis, generate files, and automate computational tasks. Code execution is typically handled by the User Proxy Agent.

Human-in-the-Loop​

AutoGen supports human-in-the-loop workflows where agents can pause execution and ask for human input, approval, or guidance at any point. This is critical for sensitive operations like financial approvals or security-critical actions.

AutoGen Architecture​

The v0.4 Architecture (2025)​

AutoGen v0.4, released in January 2025, represented a complete redesign of the framework. It introduced a three-layer architecture:

LayerPurposeComponents
autogen-coreLow-level event-driven primitivesRoutedAgent, subscriptions, pub/sub messaging
autogen-agentchatHigh-level API for most usersAssistantAgent, UserProxyAgent, GroupChat, initiate_chat
autogen-extPluggable extensionsOpenAI Assistant API, MCP tooling, gRPC distributed agents

Key improvements in v0.4:

  • Fully asynchronous: Better scalability and observability
  • Modular components: Customizable memory, models, and orchestration
  • Improved error recovery: Checkpointing mechanisms
  • Cross-language support: Primarily Python, with .NET support emerging

The AutoGen Execution Model​

  1. User input enters the system through a User Proxy Agent or directly
  2. Messages flow between agents in a conversation or group chat
  3. Agents reason using LLMs and decide on actions
  4. Tools are called when needed (API calls, database queries, etc.)
  5. Code is executed in a sandboxed environment
  6. Human approval can be requested at any point
  7. Conversation terminates when the goal is reached

AutoGen Studio​

AutoGen is complemented by AutoGen Studio, a graphical development tool that allows creating agentic workflows without writing code. It features:

  • Drag-and-drop agent workflow builder
  • Real-time agent updates
  • Mid-execution control
  • Message flow visualization

Note: In June 2026, Microsoft disclosed an exploit chain named AutoJack that turned an AI browsing agent into a delivery vehicle for remote code execution through AutoGen Studio. The flaw was in AutoGen Studio's MCP surface. This underscores the importance of security best practices when using agent frameworks, especially those with code execution capabilities.

How AutoGen Works​

The Classic Two-Agent Pattern​

The most common AutoGen pattern (covering about 60% of production deployments) is the two-agent setup: Assistant Agent + User Proxy Agent.

from autogen import AssistantAgent, UserProxyAgent

# Load configuration (usually from OAI_CONFIG_LIST or env)
config_list = config_list_from_json("OAI_CONFIG_LIST")

# Create the Assistant Agent
assistant = AssistantAgent(
    name="helpful_engineer",
    llm_config={"config_list": config_list},
    system_message="You are a senior Python engineer. Write clean, efficient code."
)

# Create the User Proxy Agent
user_proxy = UserProxyAgent(
    name="user",
    human_input_mode="NEVER",  # NEVER / ALWAYS / TERMINATE
    max_consecutive_auto_reply=10,
    code_execution_config={"work_dir": "coding", "use_docker": False}
)

# Start the conversation
user_proxy.initiate_chat(
    assistant,
    message="Write a Python class that implements a stack data structure"
)

How Agents Communicate​

Agents communicate through messages. When initiate_chat is called, the User Proxy Agent sends a message to the Assistant Agent. The Assistant Agent processes the message, generates a response, and may:

  • Write code (which the User Proxy Agent can execute)
  • Call tools
  • Request clarification
  • Signal completion

The conversation continues until:

  • A termination condition is met
  • The max_consecutive_auto_reply limit is reached
  • Human input is requested and provided

Group Chat Pattern​

For more complex workflows, AutoGen supports Group Chat where multiple agents participate:

from autogen import GroupChat, GroupChatManager

# Create specialized agents
planner = AssistantAgent(name="planner", ...)
coder = AssistantAgent(name="coder", ...)
reviewer = AssistantAgent(name="reviewer", ...)

# Create group chat
group_chat = GroupChat(
    agents=[planner, coder, reviewer, user_proxy],
    messages=[],
    max_round=20
)

# Create manager
manager = GroupChatManager(groupchat=group_chat, ...)

# Start the group chat
user_proxy.initiate_chat(
    manager,
    message="Design and implement a REST API for a task management system"
)

AutoGen Features​

1. Multi-Agent Collaboration​

AutoGen's core strength is enabling teams of specialized agents to collaborate on complex tasks. Instead of one model doing everything, agents with distinct roles work together through conversation.

2. Autonomous Conversations​

Agents can engage in autonomous, multi-turn conversations without human intervention. The conversation continues until the task is complete or a termination condition is met.

3. Tool Calling​

Agents can call external tools—APIs, databases, web search, and custom functions. This extends agents beyond text generation to actual action.

4. Code Execution​

AutoGen provides native support for sandboxed code execution. Agents can write and execute Python code, making AutoGen particularly powerful for data analysis, automation, and software development tasks.

5. Human Approval​

Human-in-the-loop is built into the framework, not bolted on. Agents can pause and request human input for sensitive decisions.

6. Agent Memory​

Agents can maintain conversation memory, remembering previous exchanges and decisions.

7. Custom Agents​

AutoGen is highly extensible. You can create custom agent classes with specialized behaviors, memory systems, and orchestration logic.

8. Flexible Conversation Patterns​

AutoGen supports multiple conversation patterns:

  • One-to-one: Two agents converse directly
  • Group chat: Multiple agents in a shared chat room
  • Hierarchical: Orchestrator agents managing sub-agents
  • Debate: Agents with opposing viewpoints

9. Extensibility​

The autogen-ext layer provides pluggable extensions for OpenAI Assistant API, MCP tooling, and gRPC distributed agents.

10. Model Agnostic Design​

AutoGen works with any LLM provider—OpenAI, Anthropic, Azure OpenAI, Ollama, Gemini, and more.

AutoGen Conversation Patterns​

One-to-One​

Two agents converse directly. Typically an Assistant Agent and a User Proxy Agent. Covers about 60% of production deployments.

Best for: Straightforward tasks, code generation, data analysis.

Group Chat​

Multiple agents participate in a shared conversation. A manager controls turn order. Group chat sits under 15% of production deployments.

Best for: Complex workflows requiring multiple specializations.

Planner–Executor​

A Planner agent breaks down the task, and Executor agents carry out the pieces.

Best for: Tasks with multiple distinct subtasks.

Planner–Reviewer​

A Planner generates solutions, and a Reviewer critiques and improves them.

Best for: Code review, document generation, quality assurance.

Debate Pattern​

Multiple agents with different perspectives debate a topic and converge on a solution.

Best for: Decision-making, risk assessment, complex reasoning.

Reflection Pattern​

Agents reflect on their own outputs and improve them through iterative feedback.

Best for: Refinement tasks, writing, code optimization.

AutoGen Code Execution​

How It Works​

AutoGen agents can write and execute code through the User Proxy Agent. The code execution environment is configurable:

code_execution_config = {
    "work_dir": "coding",      # Directory for code files
    "use_docker": False,       # Use Docker for isolation
    "timeout": 60,             # Execution timeout in seconds
    "last_n_messages": 3       # Number of messages to keep in context
}

Best Practices for Production​

  1. Sandbox execution: Use Docker or Azure Container Apps for isolation
  2. Timeout limits: Set reasonable timeouts to prevent runaway execution
  3. Input validation: Validate any user input before execution
  4. Resource limits: Constrain CPU, memory, and disk usage
  5. Audit logging: Log all code execution for compliance and debugging
  6. Security updates: Keep execution environments patched

Security Considerations​

AutoGen's code execution capability, while powerful, requires careful security consideration. The AutoJack vulnerability disclosed in June 2026 demonstrated that a single malicious web page could chain three independent weaknesses in AutoGen Studio's MCP surface to execute arbitrary code.

Key security practices:

  • Run code execution in isolated containers
  • Never execute untrusted code in production without review
  • Regularly update framework versions
  • Implement proper authentication and authorization

Common Use Cases​

Coding Assistants​

AutoGen is widely used for code generation, review, and refactoring. A typical setup: Coder agent generates code, Reviewer agent checks it, Executor agent runs tests.

Research Agents​

Multi-agent research systems where one agent searches, another synthesizes, and a third validates findings.

Customer Support​

AutoGen powers customer support triage and automation. Agents classify tickets, retrieve information, and draft responses.

Data Analysis​

Agents write and execute code to analyze data, generate reports, and create visualizations.

Document Processing​

Document extraction and processing pipelines where agents extract, summarize, and route information.

Workflow Automation​

AutoGen automates business processes by orchestrating multiple specialized agents. Agents perform research, create artifacts, and review outputs.

Enterprise Copilots​

Internal AI assistants that help employees with coding, documentation, research, and data analysis.

Software Engineering​

Code review automation where Planner, Coder, Reviewer, and Executor agents collaborate.

AutoGen Ecosystem​

Core Integrations​

  • Microsoft Agent Framework (MAF): The successor framework combining AutoGen and Semantic Kernel
  • Azure AI Foundry: Deep integration for production deployments
  • Azure Container Apps: Code interpreter sessions for secure execution

Model Providers​

AutoGen works with any LLM provider through LangChain integrations:

  • OpenAI (GPT-4, GPT-5)
  • Anthropic (Claude)
  • Azure OpenAI
  • Google Gemini
  • Ollama (local models)

Tools and Extensions​

  • MCP (Model Context Protocol): Connect to external tools, databases, and services
  • LangChain: Component integration
  • Docker: Code execution isolation

AutoGen Studio​

A no-code graphical development tool for prototyping agentic workflows. Features drag-and-drop agent workflow builder.

AutoGen Advantages​

1. Conversational Multi-Agent Design​

AutoGen pioneered the conversational multi-agent paradigm—agents as participants in a dialogue, not just function calls. This enables natural collaboration, delegation, and iteration.

2. Powerful Code Execution​

Native code execution sets AutoGen apart from many other frameworks. Agents can write, execute, and debug code in a sandboxed environment.

3. Human-in-the-Loop​

Human approval is built into the framework, enabling safe execution of sensitive actions.

4. Flexible Architecture​

The three-layer architecture (core, agentchat, extensions) provides both high-level simplicity and low-level control.

5. Rich Conversation Patterns​

Support for one-to-one, group chat, hierarchical, and debate patterns makes AutoGen versatile for many use cases.

6. Strong Research Foundation​

AutoGen was developed by Microsoft Research and has demonstrated state-of-the-art performance on multiple agentic benchmarks.

7. Active Community​

AutoGen has over 2.7 million downloads, 37k GitHub stars, and 5.4k forks.

8. Extensible Design​

Custom agents, memory systems, and orchestration logic are easy to build.

AutoGen Limitations​

1. Maintenance Mode Status​

Critical for 2026: AutoGen is no longer under active development. New projects should use Microsoft Agent Framework instead.

2. Learning Curve​

Understanding multi-agent conversations, group chat dynamics, and agent roles requires significant ramp-up time.

3. Complex Debugging​

Debugging multi-agent systems is inherently complex. Tracking which agent said what, which tool was called, and why a decision was made can be difficult.

4. Agent Coordination Overhead​

Multi-agent conversations can produce high token usage and latency. A single user request can cross multiple models, tools, and agents before returning a response.

5. Conversation Loop Risks​

Group chats can continue indefinitely without proper termination conditions.

6. Python-First​

While .NET support exists, AutoGen is primarily a Python framework.

7. Enterprise Feature Gaps​

The standalone AutoGen framework lacked some enterprise features (session-based state management, type safety, execution filters) that were present in Semantic Kernel and are now unified in MAF.

AutoGen vs Other Agent Frameworks​

Framework Comparison​

AspectAutoGenLangGraphCrewAIMicrosoft Agent Framework
PhilosophyConversational multi-agentGraph-based state machineRole-based crewsUnified enterprise agent platform
Primary UsersResearchers, early adoptersProduction engineersRapid prototypersMicrosoft ecosystem teams
State ManagementConversation-basedCheckpoint-basedTask-basedSession-based + graph-based
Code Executionâś… Nativeâś… Via toolsâś… Via toolsâś… Via tools
Human-in-the-Loopâś…âś…âś…âś…
Enterprise FeaturesLimitedModerateLimitedâś… Full
StatusMaintenance modeActiveActiveActive (1.0 GA)
When to UseLegacy systems, learning conceptsStateful production agentsRole-based pipelinesNew Microsoft ecosystem projects

Framework Selection Guide​

As one analysis notes: "LangGraph fits stateful workflows, CrewAI fits role-based crews, and AutoGen should be skipped for new projects in favor of Microsoft Agent Framework or one of the others".

Choose Microsoft Agent Framework (AutoGen's successor) when:

  • You're starting a new project
  • You need enterprise features (state management, type safety, telemetry)
  • You're in the Microsoft ecosystem (Azure, .NET, Teams)
  • You want a unified, production-ready framework

Choose LangGraph when:

  • You need durable state and checkpointing
  • You want fine-grained control over execution flow
  • You're already in the LangChain ecosystem

Choose CrewAI when:

  • You want role-based multi-agent collaboration
  • You need rapid prototyping with a clean mental model

Use AutoGen (legacy) when:

  • You're maintaining an existing AutoGen system
  • You're learning the conversational multi-agent paradigm
  • You need the specific AutoGen patterns that haven't been fully ported to MAF yet

Who Should Use AutoGen (and Its Successors)?​

Individual Developers​

AutoGen (legacy): Good for learning multi-agent concepts and conversational patterns.

Microsoft Agent Framework (new): Best for building production agent applications in Python or .NET.

AI Startups​

Microsoft Agent Framework: Provides enterprise-grade features needed for production AI products. Deep Azure integration is valuable for scaling.

Enterprise Teams​

Microsoft Agent Framework: The clear choice for Microsoft-centric enterprises. Offers session-based state management, type safety, execution filters, telemetry, and graph-based workflows.

Researchers​

AutoGen (legacy): Still useful for research and experimentation. Concepts pioneered in AutoGen continue to influence the field.

Platform Engineers​

Microsoft Agent Framework: Build internal agent platforms with full observability, governance, and integration with Azure AI Foundry.

Best Practices​

For AutoGen (Legacy)​

  1. Keep agent roles focused—don't overload a single agent with too many responsibilities
  2. Minimize unnecessary conversations—more turns = more tokens + latency
  3. Validate tool outputs—never trust tool output without checking
  4. Monitor execution costs—multi-agent conversations can be expensive
  5. Design clear termination conditions—prevent runaway conversations
  6. Add human approval for critical actions—financial transactions, security-sensitive operations
  7. Log agent interactions—critical for debugging and compliance
  8. Implement fallback strategies—what happens when an agent fails?

For Microsoft Agent Framework (New)​

  1. Start with AgentChat for prototyping—the high-level API is beginner-friendly
  2. Move to Core for production—event-driven, scalable, distributed
  3. Use Pydantic for data validation—prevents bugs from wrong data types
  4. Leverage MCP integration—connect agents to external tools and services
  5. Deploy to Foundry Agent Service—for production with persistent chat history
  6. Enable telemetry—monitor agent performance and costs

Frequently Asked Questions​

What is AutoGen?​

AutoGen is an open-source framework for building conversational multi-agent LLM applications where agents exchange messages, call tools, execute code, and involve human reviewers. Originally developed by Microsoft Research.

Is AutoGen open source?​

Yes. AutoGen is open source.

Is AutoGen developed by Microsoft?​

Yes. AutoGen was originally developed by Microsoft Research's AI Frontiers Lab.

Can AutoGen build multi-agent systems?​

Yes. AutoGen is specifically designed for multi-agent systems where specialized agents collaborate through conversation.

Does AutoGen support code execution?​

Yes. AutoGen provides native support for sandboxed code execution. Agents can write and execute Python code.

Can AutoGen call external tools?​

Yes. AutoGen agents can call tools—APIs, databases, web search, and custom functions.

Is AutoGen suitable for production?​

AutoGen has been used in production, but for new projects, Microsoft recommends using Microsoft Agent Framework (MAF) instead. MAF reached version 1.0 and general availability in April 2026.

How does AutoGen compare with LangGraph?​

AutoGen uses conversational multi-agent loops. LangGraph uses graph-based control flow with explicit state machines. LangGraph is the better choice for stateful production agents; AutoGen's successor (MAF) now offers graph-based workflows as well.

What is the Microsoft Agent Framework?​

The Microsoft Agent Framework (MAF) is the unified successor to AutoGen and Semantic Kernel, combining AutoGen's agent abstractions with Semantic Kernel's enterprise-grade features. It reached version 1.0 GA in April 2026.

Should I use AutoGen or Microsoft Agent Framework for new projects?​

Use Microsoft Agent Framework. AutoGen and Semantic Kernel entered maintenance mode in October 2025. All new features and protocol support are being developed on MAF.

Conclusion​

AutoGen pioneered the conversational multi-agent paradigm that has become central to modern agentic AI. Its influence is undeniable—the framework demonstrated that specialized agents working together through conversation could outperform single-model systems by 2–10x on complex tasks.

However, for developers building new projects in 2026, the landscape has shifted. AutoGen and Semantic Kernel have merged into the Microsoft Agent Framework (MAF) , which reached version 1.0 and general availability in April 2026. MAF combines AutoGen's intuitive agent abstractions with Semantic Kernel's enterprise-grade features—session-based state management, type safety, execution filters, and telemetry.

The framework selection guidance for 2026 is clear:

  • New projects: Choose Microsoft Agent Framework
  • LangChain ecosystem: Choose LangGraph for stateful workflows
  • Role-based pipelines: Choose CrewAI
  • Legacy AutoGen systems: Maintain but don't build new features

Understanding AutoGen remains valuable—its concepts and patterns live on in MAF, and many production systems still run on AutoGen. But the future of Microsoft's agent framework strategy is firmly with MAF.

Whether you're an individual developer building agent applications, an enterprise team deploying AI assistants, or a platform engineer creating internal agent infrastructure, the Microsoft Agent Framework provides the production-ready foundation that AutoGen pioneered.