CtrlK
AutoGen is an open-source programming framework developed by Microsoft Research for building AI agents and enabling cooperation among multiple agents to solve tasks. Originally released in October 2023, AutoGen introduced a conversation-driven approach to multi-agent systems, allowing developers to create customizable agents powered by large language models (LLMs), human inputs, and tools that collaborate through structured conversations. The framework became one of the most popular open-source projects in the agentic AI space, accumulating over 54,000 stars on GitHub and millions of downloads.
AutoGen's foundational paper, "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation," was published as a conference paper at COLM 2024 and received the Best Paper award at the LLM Agents Workshop at ICLR 2024. The framework has since gone through a major architectural redesign with version 0.4 in January 2025, and its concepts were eventually merged into the broader Microsoft Agent Framework announced in October 2025.
AutoGen originated within FLAML (Fast Library for Automated Machine Learning), an open-source AutoML project at Microsoft Research. The initial AutoGen module was created inside FLAML on March 29, 2023, by researchers Qingyun Wu and Chi Wang, along with collaborators from Penn State University, the University of Washington, Stevens Institute of Technology, and other institutions.
The first version of the AutoGen paper (arXiv:2308.08155) appeared on August 16, 2023, describing a framework for building LLM applications through multi-agent conversations. On October 3, 2023, AutoGen was spun off from FLAML into its own standalone repository on GitHub under the microsoft/autogen organization. The project gained rapid traction: within 35 days of its spinoff, AutoGen was selected into the Open100 list of top 100 open-source achievements, and TheSequence named the AutoGen paper one of the five best AI papers of 2023.
The full author list of the foundational paper includes Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, Ahmed Hassan Awadallah, Ryen W. White, Doug Burger, and Chi Wang.
In September 2024, some of AutoGen's original creators, including Chi Wang and Qingyun Wu, departed Microsoft. By November 2024, they established a new organization called AG2AI and forked the AutoGen codebase into a project called AG2 (formerly AutoGen). The founders cited two main reasons for the split: the desire to move faster without corporate constraints, and the goal of creating a more neutral space for contributions from various organizations.
AG2 inherited the autogen and pyautogen PyPI packages as well as the original Discord community of over 20,000 members. The project adopted the Apache 2.0 license starting from version 0.3. AG2 maintains backward compatibility with AutoGen 0.2's architecture and API, offering stability for existing users while pursuing its own roadmap under community governance.
Meanwhile, the Microsoft-maintained microsoft/autogen repository underwent a complete architectural redesign, releasing version 0.4 in January 2025 with a fundamentally different codebase.
In October 2025, Microsoft announced the Microsoft Agent Framework, which merges AutoGen's multi-agent orchestration capabilities with Semantic Kernel's enterprise features. The Agent Framework combines AutoGen's agent abstractions with Semantic Kernel's session-based state management, type safety, middleware, telemetry, and graph-based workflows for multi-agent orchestration.
Microsoft released the Agent Framework in public preview on October 1, 2025, targeting a 1.0 General Availability release by the end of Q1 2026. Following this announcement, AutoGen entered maintenance mode, receiving only bug fixes and security patches, while new feature development shifted to the Microsoft Agent Framework.
AutoGen's architecture has evolved significantly across its versions. The framework provides two main API layers in version 0.4: the Core API for low-level, event-driven agent development, and the AgentChat API for high-level, task-driven multi-agent applications.
The Core API is the foundation layer of AutoGen 0.4. It provides a scalable, event-driven actor framework for creating agentic workflows. The Core API is built on the Actor model, a computational paradigm where each agent operates independently, manages its own state, and communicates with other agents through asynchronous message passing.
Key components of the Core API include:
| Component | Description |
|---|---|
| Agents | Independent units that handle and produce typed messages in response to events |
| Runtime | Manages message delivery between agents, decoupling transport from agent logic |
| Direct messaging | Functions like remote procedure calls (RPC) for point-to-point communication |
| Topic-based messaging | Implements a publish-subscribe (pub/sub) pattern for broadcasting messages |
| Distributed runtime | Uses gRPC to enable agents to run across multiple processes and machines |
The Core API supports cross-language interoperability, allowing agents written in different programming languages to communicate with one another. At launch, AutoGen 0.4 supported Python and .NET, with additional language support planned.
The AgentChat API is a higher-level abstraction built on top of the Core API. It provides a task-driven framework designed for rapid prototyping of interactive multi-agent applications. AgentChat offers preset agent types and team configurations that implement common multi-agent design patterns.
The primary agent types in AgentChat include:
| Agent type | Description |
|---|---|
| AssistantAgent | Uses an LLM to generate responses; can be equipped with tools, memory modules, and custom system prompts |
| UserProxyAgent | Acts as a proxy for a human user, soliciting input during a conversation to enable human-in-the-loop workflows |
| CodeExecutorAgent | Executes code generated by other agents in a sandboxed environment |
In AutoGen 0.4, agents are organized into "teams" that implement specific collaboration patterns. Teams serve as the fundamental building block in the AgentChat API, replacing the GroupChat concept from version 0.2.
| Team type | Description |
|---|---|
| RoundRobinGroupChat | Agents take turns broadcasting messages to all participants in a sequential, cyclic order |
| SelectorGroupChat | An LLM selects which agent should speak next after each message, enabling dynamic turn-taking |
| Swarm | The next speaker is determined by handoff messages from the current speaker, allowing agents to delegate control explicitly |
All team types share a common context: every agent in a team can see all messages from other team members. Teams also support configurable termination conditions that determine when a conversation should end.
AutoGen 0.4 provides several built-in termination conditions for controlling when agent conversations stop:
| Condition | Behavior |
|---|---|
| MaxMessageTermination | Stops after a specified number of messages |
| TextMentionTermination | Stops when a specific text string appears in an agent's response |
| HandoffTermination | Stops when an agent requests a handoff to a specific target |
| SourceMatchTermination | Stops when a particular agent responds |
| ExternalTermination | Enables programmatic termination from outside the running team |
Multiple termination conditions can be combined using logical AND and OR operators. Termination conditions are stateful but reset automatically between runs.
AutoGen 0.2, the original version of the framework, introduced the core concepts that made multi-agent conversation systems accessible to developers. While superseded by version 0.4, many of AutoGen 0.2's ideas remain influential in the broader ecosystem, and the AG2 fork continues to maintain this architecture.
The ConversableAgent class was the central abstraction in AutoGen 0.2. It represented a generic agent capable of conversing with other agents through message exchange. After receiving each message, a ConversableAgent would automatically send a reply to the sender unless the message was a termination signal. Developers could customize agent behavior by registering reply functions using the register_reply() method.
AutoGen 0.2 provided two specialized subclasses:
For conversations involving more than two agents, AutoGen 0.2 offered a GroupChat pattern orchestrated by a GroupChatManager. In this pattern, the GroupChatManager selected which agent should speak next, the selected agent generated a response, and the GroupChatManager broadcast that response to all other agents in the group. This cycle repeated until a termination condition was met.
The GroupChatManager supported several speaker selection strategies, including round-robin ordering, random selection, and LLM-based selection where an LLM chose the most appropriate next speaker based on conversation context.
A distinctive feature of AutoGen from its earliest versions was built-in support for code execution. In a typical workflow, an AssistantAgent would generate code (often Python), and a UserProxyAgent would execute that code in a sandboxed environment, returning the output to the conversation. This created a feedback loop where the AssistantAgent could debug and refine its code based on execution results.
AutoGen supported multiple code execution backends, including local execution, Docker containers, and the Azure Container Apps dynamic sessions for cloud-based sandboxing.
AutoGen 0.4 introduced asynchronous messaging as a core architectural principle. Agents communicate through async messages, supporting both event-driven and request/response interaction patterns. This design enables more scalable systems compared to the synchronous conversation model in version 0.2.
The framework is designed around pluggable components. Developers can swap out or extend individual pieces, including custom agents, tools, memory modules, and model clients, without modifying the framework's core. This modularity makes it possible to build proactive, long-running agents that go beyond simple request-response patterns.
AutoGen 0.4 provides a unified interface for working with different LLM providers through model clients:
| Model client | Provider |
|---|---|
| OpenAIChatCompletionClient | OpenAI models and OpenAI-compatible APIs (including Gemini) |
| AzureOpenAIChatCompletionClient | Azure OpenAI Service models |
| AnthropicChatCompletionClient | Anthropic Claude models (experimental) |
| AzureAIChatCompletionClient | GitHub Models and Azure-hosted models |
| OllamaChatCompletionClient | Local models via Ollama (experimental) |
AutoGen provides built-in support for human-in-the-loop workflows through the UserProxyAgent. When a team calls the UserProxyAgent during execution, it pauses the conversation and solicits input from a human user before continuing. This allows humans to provide feedback, correct agent behavior, approve actions, or inject domain knowledge at critical points in a workflow.
AutoGen 0.4 includes stronger observability features compared to earlier versions. Developers can view agent action streams in real time, inspect message flows between agents, and use mid-execution controls to pause conversations, redirect agent actions, or adjust team composition while a workflow is running.
AutoGen Studio is a low-code, web-based interface for building, testing, and sharing multi-agent workflows. Originally introduced as a research prototype by Microsoft Research, AutoGen Studio was rebuilt on the AutoGen 0.4 AgentChat API in January 2025.
The tool provides a declarative, JSON-based specification format for defining agents and teams, along with a drag-and-drop visual interface for composing workflows. Key features include:
AutoGen Studio is described as a prototyping tool rather than a production-ready application. Microsoft recommends that developers use AutoGen Studio for rapid experimentation and then build production applications using the AutoGen framework directly, implementing their own authentication, security, and deployment features.
A dedicated paper on AutoGen Studio, "AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems," was published at EMNLP 2024 (arXiv:2408.15247).
Magentic-One is a generalist multi-agent system built on AutoGen for solving complex, open-ended tasks involving web browsing and file manipulation. Released by Microsoft Research in November 2024, it demonstrates how AutoGen's multi-agent architecture can be applied to challenging real-world benchmarks.
Magentic-One uses a team of five specialized agents coordinated by an Orchestrator:
| Agent | Role |
|---|---|
| Orchestrator | Creates plans, delegates tasks to other agents, and tracks progress; dynamically revises plans as needed |
| WebSurfer | Handles browser-based tasks such as navigating web pages, clicking elements, and reading content |
| FileSurfer | Manages file-related operations including reading, writing, and transforming documents |
| Coder | Writes and analyzes code to solve computational problems |
| ComputerTerminal | Executes code and performs system-level operations |
In benchmarks, Magentic-One achieved 38% on GAIA, 27.7% on AssistantBench, and 32.8% on WebArena, results that were statistically comparable to previous state-of-the-art methods at the time of release. The system was published as a research paper (arXiv:2411.04468) and released as an open-source package within the AutoGen repository.
AutoGen has been applied across a variety of domains. The original paper and subsequent research demonstrated effectiveness in several areas:
| Domain | Application |
|---|---|
| Mathematics | Multi-agent conversations for solving math problems, with agents debating solutions and verifying each other's work |
| Code generation | Automated code writing, execution, and debugging through iterative agent collaboration |
| Retrieval-augmented generation | RetrieveChat combines retrieval-augmented agents with code generation for question answering over custom documents |
| Question answering | Multi-agent systems that decompose complex questions and synthesize answers from multiple perspectives |
| Supply chain optimization | Agents collaborating to model and solve complex optimization problems |
| Online decision-making | Agents operating in interactive text-based environments, making sequential decisions |
| Research workflows | Groups of agents performing literature review, data analysis, and report generation |
The framework's conversational design also enables a novel interactive retrieval feature: when retrieved context lacks needed information, an LLM-based assistant can request additional retrieval attempts rather than terminating the conversation, allowing for iterative refinement of search results.
AutoGen is one of several prominent frameworks for building multi-agent systems. Each framework takes a different architectural approach.
| Feature | AutoGen | CrewAI | LangGraph |
|---|---|---|---|
| Architecture | Conversation-driven; agents collaborate through structured dialogue | Role-based; agents modeled as team members with specific responsibilities | Graph-based; agent interactions defined as nodes in a directed graph |
| Design philosophy | Natural language interactions with dynamic role adaptation | Organizational metaphor with clear role assignments | Stateful workflows with explicit control flow |
| Strengths | Group decision-making, debate scenarios, flexible conversation patterns | Quick setup for business workflow automation, intuitive role-based modeling | Fine-grained state management, complex conditional logic, production durability |
| Learning curve | Moderate; two API layers (Core and AgentChat) offer different abstraction levels | Low; YAML-driven configuration is straightforward | Higher; graph-based model requires understanding of state machines |
| Low-code tooling | AutoGen Studio provides drag-and-drop interface | YAML configuration files | LangGraph Studio for visualization |
| Human-in-the-loop | Built-in UserProxyAgent | Supported through agent configuration | Supported through interrupt nodes |
| Language support | Python, .NET | Python | Python, JavaScript/TypeScript |
The choice between frameworks depends on the specific use case. AutoGen is particularly well suited for conversational multi-agent systems where agents need to engage in flexible, back-and-forth dialogue. CrewAI works well for structured business workflows where roles are clearly defined. LangGraph is a strong choice for applications requiring precise state management and complex branching logic, especially for teams already using LangChain.
AutoGen 0.4 requires Python 3.10 or later. The framework can be installed using pip:
pip install -U "autogen-agentchat" "autogen-ext[openai]"
A basic example using the AgentChat API:
import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
async def main():
model_client = OpenAIChatCompletionClient(model="gpt-4o")
agent = AssistantAgent(
name="assistant",
model_client=model_client,
system_message="You are a helpful assistant.",
)
response = await agent.on_messages(
[TextMessage(content="What is AutoGen?", source="user")],
cancellation_token=CancellationToken(),
)
print(response.chat_message.content)
asyncio.run(main())
For team-based workflows, agents can be composed into teams:
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import MaxMessageTermination
team = RoundRobinGroupChat(
participants=[agent_1, agent_2],
termination_condition=MaxMessageTermination(max_messages=10),
)
result = await team.run(task="Analyze this dataset and write a summary.")
AutoGen has had a significant impact on the agentic AI landscape since its release. Key metrics include:
| Metric | Value |
|---|---|
| GitHub stars | Over 54,600 (as of early 2026) |
| Monthly downloads | Over 856,000 |
| GitHub commits | Over 3,776 |
| Contributors | Over 559 |
| Releases | 98 |
| Issues resolved | Over 2,488 |
The AutoGen paper has been widely cited in academic research on multi-agent systems, LLM agents, and agentic workflows. The framework's concepts, particularly the idea of multi-agent conversation as a programming paradigm, influenced the design of subsequent agent frameworks and contributed to broader industry interest in multi-agent AI systems.
AutoGen was recognized by multiple awards and accolades, including the Best Paper award at the LLM Agents Workshop at ICLR 2024, selection into the Open100 top 100 open-source achievements, and being named one of the five best AI papers of 2023 by TheSequence.
As of early 2026, the AutoGen ecosystem exists in several forms:
microsoft/autogen repository. Now in maintenance mode, receiving bug fixes and security patches only. New development has shifted to the Microsoft Agent Framework.Microsoft provides a migration guide for users transitioning from AutoGen to the Microsoft Agent Framework, available on Microsoft Learn.