AutoGen

AutoGen is an open-source programming framework developed by Microsoft Research for building AI agents and enabling cooperation among multiple agents to solve tasks.^[3] 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.^[1] 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.^[2]

AutoGen was one of the earliest frameworks to demonstrate the power of multi-agent conversation for solving complex tasks, and its research paper became one of the most cited works in the agentic AI space.^[1] The framework underwent a complete rewrite from version 0.2 to version 0.4 in 2024, adopting an event-driven, asynchronous architecture.^[4] In October 2025, Microsoft announced that AutoGen would be merged with Semantic Kernel into the new Microsoft Agent Framework, with AutoGen entering maintenance mode.^[9]

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.^[1] The paper has accumulated more than 850 citations on Semantic Scholar, making it one of the most referenced works in the multi-agent AI literature.^[1] The framework has since gone through a major architectural redesign with version 0.4, released on January 14, 2025, which Microsoft described as "a complete redesign of the AutoGen library, developed to improve code quality, robustness, generality, and scalability in agentic workflows."^[4] Its concepts were eventually merged into the broader Microsoft Agent Framework, announced in October 2025 and released as version 1.0 on April 3, 2026.^[9][22]

History and development

Origins at Microsoft Research

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.^[1]

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.^[1] On October 3, 2023, AutoGen was spun off from FLAML into its own standalone repository on GitHub under the microsoft/autogen organization.^[2] 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 paper was led by researchers including Qingyun Wu, Gagan Bansal, Jieyu Zhang, and Chi Wang.^[1] The framework was released as open-source software on GitHub coinciding with a surge of interest in LLM-powered agents following the release of GPT-4 and the growing recognition that single-agent systems had significant limitations for complex, multi-step tasks. The paper has since accumulated over 850 citations on Semantic Scholar, making it one of the most referenced works in the multi-agent AI literature.^[1]

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.^[1]

The core insight behind AutoGen was that many complex tasks could be decomposed into conversations between specialized agents, each with distinct capabilities and roles. Rather than building a single monolithic agent that tries to handle everything, developers could compose multiple simpler agents that collaborate through natural language dialogue. This conversational approach proved both intuitive for developers and effective for a wide range of applications, from code generation to research synthesis.

What is the AG2 fork?

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).^[12] 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.^[13]

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.^[12] 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.^[12]

This split created significant confusion in the ecosystem. AG2 maintained backward compatibility with AutoGen 0.2's API (releasing as version 0.3.2) and continued developing features on the familiar architecture. Meanwhile, Microsoft pursued its complete rewrite as AutoGen 0.4 under the autogen-core and autogen-agentchat package names.^[4] Microsoft's team publicly noted that "the current pyautogen package isn't affiliated with Microsoft AutoGen, and admin access is blocked for us," clarifying the package ownership situation.^[13]

The fork resulted in four distinct variants of AutoGen-derived software:^[13]

Scroll sideways for more →

Meanwhile, the Microsoft-maintained microsoft/autogen repository underwent a complete architectural redesign, releasing version 0.4 in January 2025 with a fundamentally different codebase.^[4][5]

Microsoft Agent Framework

In October 2025, Microsoft announced the Microsoft Agent Framework, which merges AutoGen's multi-agent orchestration capabilities with Semantic Kernel's enterprise features.^[9] 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.^[10]

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.^[9][10] Following this announcement, AutoGen entered maintenance mode, receiving only bug fixes and security patches, while new feature development shifted to the Microsoft Agent Framework.^[11]

Architecture

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.^[4]

Layered architecture

AutoGen 0.4 introduced a layered architecture separating concerns across three tiers:^[4]

Scroll sideways for more →

The Core layer's actor model provided natural concurrency (agents process messages independently), fault isolation (a failure in one agent does not crash others), and scalability (agents can be distributed across multiple processes or machines). Agents communicated through both event-driven (publish/subscribe) and request/response interaction patterns.^[4]

Core API

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.^[4]

Key components of the Core API include:

Scroll sideways for more →

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.^[4][19]

AgentChat API

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.^[15] AgentChat offers preset agent types and team configurations that implement common multi-agent design patterns.

The primary agent types in AgentChat include:

Scroll sideways for more →

One of the most notable simplifications was tool use. In 0.2, tools required registration with separate caller and executor agents. In 0.4, a single AssistantAgent can both decide to call tools and execute them:^[16]

assistant = AssistantAgent(
    name="assistant",
    model_client=OpenAIChatCompletionClient(model="gpt-4o"),
    tools=[get_weather, search_database]
)

Model client configuration also changed from dictionary-based llm_config to direct instantiation of typed client objects, improving type safety and developer experience.^[16]

Teams

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.^[17]

Scroll sideways for more →

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. All teams support two execution methods: run() for synchronous execution until termination, and run_stream() for yielding messages as they are generated in real time. Teams are stateful objects that preserve context between runs unless explicitly reset with the reset() method.^[17]

Termination conditions

AutoGen 0.4 provides several built-in termination conditions for controlling when agent conversations stop:^[15]

Scroll sideways for more →

Multiple termination conditions can be combined using logical AND and OR operators (for example using the bitwise OR operator |): TextMentionTermination("DONE") | MaxMessageTermination(20) would stop the conversation when either condition was met. Termination conditions are stateful but reset automatically between runs.

State management and serialization

AutoGen 0.4 added built-in state management capabilities that were absent from version 0.2:^[4]

Scroll sideways for more →

Cross-language support

AutoGen 0.4 expanded beyond Python to include .NET support, enabling interoperability between agents built in different programming languages.^[4] This was a significant addition for enterprise environments where applications span multiple technology stacks.

AutoGen 0.2 (legacy)

AutoGen 0.2, the original version of the framework, introduced the core concepts that made multi-agent conversation systems accessible to developers.^[18] 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.^[12]

ConversableAgent

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.^[18]

AutoGen 0.2 provided two specialized subclasses:

Scroll sideways for more →

The ConversableAgent employed a reply function chain to determine how to respond to incoming messages. By default, the following functions were checked in order:

1. check_termination_and_human_reply: Checks whether the conversation should end or human input is needed
2. generate_function_call_reply: Handles legacy function call responses
3. generate_tool_calls_reply: Handles tool call responses from the LLM
4. generate_code_execution_reply: Extracts and executes code blocks from messages
5. generate_oai_reply: Generates a response using the configured LLM

When a function returned final=False, the next function in the chain was checked. This chain-of-responsibility pattern gave developers fine-grained control over agent behavior.

Conversation patterns

AutoGen 0.2 supported four primary conversation patterns, each suited to different use cases:^[18]

Scroll sideways for more →

The Group Chat pattern was AutoGen 0.2's most distinctive feature. Using a GroupChatManager, multiple agents could participate in a shared conversation, with the manager deciding which agent should speak next based on the conversation context. This enabled complex multi-agent workflows where, for example, a researcher agent, a coder agent, and a critic agent could collaborate on a task through natural conversation. 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.^[18]

Tool use in AutoGen 0.2

AutoGen 0.2 implemented tool use through a two-step registration process. A tool (function) had to be registered with at least two agents to be useful: one agent registered with the tool's signature through register_for_llm (allowing it to suggest calling the tool), and another agent registered with the tool's function object through register_for_execution (allowing it to actually run the tool). The autogen.register_function convenience method could register a tool with both agents simultaneously.^[18]

Tool functions required type hints for all arguments and return values, as these provided the LLM with information about the tool's expected inputs and outputs. This design separated the "thinking" (deciding to call a tool) from the "doing" (executing the tool), which was useful for safety and auditability but added complexity compared to later frameworks.

Code execution

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.^[18]

Built-in code execution was one of AutoGen 0.2's most powerful features. The UserProxyAgent could automatically extract code blocks from agent messages and execute them. The framework supported multiple execution environments:

Scroll sideways for more →

The code_execution_config parameter controlled execution behavior, including the working directory, whether to use Docker, the Docker image to use, and the timeout for execution. The last_n_messages parameter determined how many previous messages to scan for code blocks, with 'auto' scanning all messages since the agent last spoke.

AutoGen 0.2 gained rapid adoption, particularly in academic and research settings. Its conversation-driven approach was intuitive for building prototypes and exploring multi-agent dynamics. However, users encountered limitations in production environments, including challenges with state management, scalability, error handling, and debugging complex multi-agent interactions.

Key features

Asynchronous messaging

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.^[4]

Modularity and extensibility

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.^[4] This modularity makes it possible to build proactive, long-running agents that go beyond simple request-response patterns.

Model client support

AutoGen 0.4 provides a unified interface for working with different LLM providers through model clients:^[15]

Scroll sideways for more →

Different agents within the same team can use different models, enabling cost optimization. For example, a routing agent might use a smaller, cheaper model for deciding which specialist to invoke, while the specialist agents use more capable (and expensive) models for complex reasoning.

Human-in-the-loop

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.^[15]

Observability

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.^[4]

What is AutoGen Studio?

AutoGen Studio is a low-code, web-based interface for building, testing, and sharing multi-agent workflows.^[6] Originally introduced as a research prototype by Microsoft Research alongside AutoGen 0.2, AutoGen Studio was rebuilt on the AutoGen 0.4 AgentChat API in January 2025, incorporating the new event-driven architecture and providing a significantly improved developer experience.^[20]

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.^[6]

Key features

Scroll sideways for more →

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.^[20] It serves as both a prototyping tool for developers exploring multi-agent designs and a debugging environment for understanding how agents interact during execution.

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).^[6]

What is Magentic-One?

Magentic-One is a generalist multi-agent system built on AutoGen for solving complex, open-ended tasks involving web browsing and file manipulation.^[7] Released by Microsoft Research in November 2024, it demonstrates how AutoGen's multi-agent architecture can be applied to challenging real-world benchmarks.^[8] The paper was authored by Adam Fourney, Gagan Bansal, Hussein Mozannar, Cheng Tan, and 15 other researchers at Microsoft.^[7]

Architecture

Magentic-One uses a hierarchical architecture centered on an Orchestrator agent that coordinates four specialized agents:^[7]

Scroll sideways for more →

The Orchestrator uses a structured planning approach: it creates an initial plan based on the task description, assigns sub-tasks to specialized agents, monitors their progress, and replans when agents encounter obstacles or produce unexpected results. This hierarchical delegation pattern is a key differentiator from flat group chat approaches, as it provides more structured control over complex workflows.

Benchmark performance

Magentic-One achieved competitive performance on several multi-agent benchmarks when evaluated with GPT-4o and o1-preview as its backbone models:^[7]

Scroll sideways for more →

Its modular design means that individual agents can be upgraded independently (for example, replacing the underlying LLM for the Coder agent with a newer model) without restructuring the entire system. The paper demonstrated that Magentic-One achieved these results "without modification to core agent capabilities or to how they collaborate," showing progress toward truly generalist agentic systems.^[7] The system was published as a research paper (arXiv:2411.04468) and released as an open-source package within the AutoGen repository.^[7]

When AutoGen 0.4 shipped in January 2025, Magentic-One was ported from the lower-level autogen-core library to the higher-level autogen-agentchat API, making it available as the MagenticOneGroupChat team type for easier use by developers.^[4]

Technical details

Actor model (AutoGen 0.4 Core)

AutoGen 0.4's core architecture is based on the actor model, a well-established pattern in distributed systems where each agent is an independent "actor" that communicates with other actors exclusively through asynchronous messages.^[4] This design provides:

Scroll sideways for more →

The Core layer supports two communication patterns: direct messaging (request/response) and topic-based publish/subscribe for event-driven workflows. Agents register with a runtime that handles message routing, serialization, and lifecycle management.

Model support

AutoGen supports a wide range of LLM providers through its model client abstraction:^[15]

Scroll sideways for more →

Code execution environments

AutoGen provides multiple options for executing code generated by agents, with increasing levels of isolation and security:

Scroll sideways for more →

The CodeExecutorAgent in AutoGen 0.4 provides a dedicated agent type for code execution, separating this concern from the AssistantAgent that generates code. This separation improves security by allowing different trust and isolation levels for code generation versus code execution.

Ecosystem and integrations

AutoGen integrates with a broad ecosystem of tools and services:

Scroll sideways for more →

The Extensions layer provides pre-built integrations with popular services and can be extended with custom tools written as Python functions with type annotations.

Transition to Microsoft Agent Framework

In October 2025, Microsoft announced the Microsoft Agent Framework, a new open-source platform that merges AutoGen's multi-agent orchestration capabilities with Semantic Kernel's enterprise-grade features.^[9] This announcement represented the most significant change in AutoGen's trajectory since its creation.

Rationale

Microsoft had maintained two parallel agent-building frameworks: AutoGen (focused on multi-agent research and prototyping) and Semantic Kernel (focused on enterprise AI integration with robust state management, telemetry, and middleware). The existence of two overlapping frameworks created confusion for developers about which to use. The Microsoft Agent Framework resolved this by combining the strengths of both into a single, unified SDK.^[11]

What the merger means

The Microsoft Agent Framework combines AutoGen's simple agent abstractions (like ChatAgent) with Semantic Kernel's enterprise features, including session-based state management, type safety, filters, telemetry, and extensive model and embedding support.^[10] Beyond merging the two, Agent Framework introduces graph-based workflows for explicit multi-agent orchestration and a robust state management system for long-running and human-in-the-loop scenarios.^[9]

Key migration mappings from AutoGen to the Microsoft Agent Framework:^[14]

Scroll sideways for more →

Timeline

Scroll sideways for more →

Both AutoGen and Semantic Kernel continue to receive bug fixes and security patches but no new feature investments. Microsoft recommends that teams migrate to the Agent Framework within 6 to 12 months.^[11] A detailed migration guide is available on Microsoft Learn.^[14]

Use cases and applications

AutoGen has been applied across a variety of domains. The original paper and subsequent research demonstrated effectiveness in several areas:^[1]

Scroll sideways for more →

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.

How does AutoGen compare with other frameworks?

AutoGen (and its successor, the Microsoft Agent Framework) competes primarily with CrewAI and LangGraph (part of the LangChain ecosystem) in the multi-agent framework space.^[21]

Architecture comparison

Scroll sideways for more →

Strengths and best use cases

Scroll sideways for more →

Learning curve

CrewAI is generally considered the most beginner-friendly of the three, requiring minimal boilerplate code and offering YAML-based configuration files. AutoGen falls in the middle: its two API layers (Core and AgentChat) offer different abstraction levels, using Pythonic agent classes that are straightforward but require understanding its agent and team abstractions. LangGraph has the steepest learning curve because developers need to understand graph theory concepts such as nodes, edges, and state schemas.^[21]

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.^[21]

Current status (2026)

Scroll sideways for more →

Installation and quick start

AutoGen 0.4 requires Python 3.10 or later. The framework can be installed using pip:^[15]

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.")

Impact and adoption

AutoGen has had a significant impact on the agentic AI landscape since its release. AutoGen has built one of the largest communities in the multi-agent AI space. Key metrics as of early 2026:^[2]

Scroll sideways for more →

The AutoGen paper has been widely cited in academic research on multi-agent systems, LLM agents, and agentic workflows.^[1] 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.

The framework has been particularly popular in academic and research settings, where its conversation-driven approach and built-in code execution make it well-suited for experimental and exploratory work. Enterprise adoption has been growing, particularly among organizations already using Microsoft's cloud platform, and the transition to the Microsoft Agent Framework is expected to accelerate this trend. AutoGen's concepts, including conversable agents, group chat, and human-in-the-loop patterns, have influenced virtually every multi-agent framework that followed. Its pioneering role in demonstrating that complex tasks could be solved through structured multi-agent conversation helped establish an entire category of AI tooling.

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.^[1]

Current status

As of early 2026, the AutoGen ecosystem exists in several forms:

• Microsoft AutoGen (v0.4): The last major version under the microsoft/autogen repository. Now in maintenance mode, receiving bug fixes and security patches only. New development has shifted to the Microsoft Agent Framework.^[11]
• Microsoft Agent Framework: The successor to both AutoGen and Semantic Kernel, combining multi-agent orchestration with enterprise production features. It entered public preview in October 2025, published Release Candidate 1.0 on February 19, 2026, and reached General Availability as version 1.0 on April 3, 2026 for both Python and .NET.^[9][22]
• AG2: The community-driven fork maintained by AG2AI, continuing development based on the AutoGen 0.2 architecture with its own roadmap toward version 1.0. AG2 Beta introduces a streaming, event-driven architecture with multi-provider LLM support covering OpenAI, Anthropic, Google Gemini, Alibaba DashScope, and Ollama.^[12]

Magentic-One continues to serve as a reference implementation and has been updated to work with the Microsoft Agent Framework. AutoGen Studio has been adapted to the new framework, maintaining its visual building capabilities while gaining access to the broader feature set. The Magentic orchestration pattern is available as a first-class orchestration option in the Agent Framework.

The multi-agent framework landscape remains highly competitive, with CrewAI, LangGraph, OpenAI's Agents SDK, Google's Agent Development Kit, and Amazon's Strands Agents all competing for developer adoption. AutoGen's legacy as one of the pioneering frameworks in this space is secure, and its future continues through the Microsoft Agent Framework ecosystem.

Microsoft provides a migration guide for users transitioning from AutoGen to the Microsoft Agent Framework, available on Microsoft Learn.^[14]

See also

• AI agents
• Multi-agent system
• Large language model
• LangChain
• CrewAI
• LangGraph
• Semantic Kernel
• Tool use
• Human-in-the-loop
• Actor model

References

1. Wu, Q., Bansal, G., Zhang, J., Wu, Y., Li, B., Zhu, E., Jiang, L., Zhang, X., Zhang, S., Liu, J., Awadallah, A. H., White, R. W., Burger, D., & Wang, C. (2023). "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation." arXiv:2308.08155. Published at COLM 2024. https://arxiv.org/abs/2308.08155 ↩
2. GitHub. "microsoft/autogen: A programming framework for agentic AI." https://github.com/microsoft/autogen ↩
3. Microsoft Research. "AutoGen: An Open-Source Programming Framework for Agentic AI." https://www.microsoft.com/en-us/research/project/autogen/ ↩
4. Microsoft Research Blog. "AutoGen v0.4: Reimagining the foundation of agentic AI for scale, extensibility, and robustness." January 2025. https://www.microsoft.com/en-us/research/blog/autogen-v0-4-reimagining-the-foundation-of-agentic-ai-for-scale-extensibility-and-robustness/ ↩
5. Microsoft AutoGen Blog. "AutoGen reimagined: Launching AutoGen 0.4." January 2025. https://devblogs.microsoft.com/autogen/autogen-reimagined-launching-autogen-0-4/ ↩
6. Dibia, V., Chen, J., Bansal, G., Syed, S., Fourney, A., Zhu, E., Wang, C., & Amershi, S. (2024). "AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems." arXiv:2408.15247. Published at EMNLP 2024. ↩
7. Fourney, A., Bansal, G., Mozannar, H., Tan, C., Zhu, E., Begel, A., Amershi, S., Horton, E., Biosse Duplan, N., Tran, R., & others. (2024). "Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks." arXiv:2411.04468. https://arxiv.org/abs/2411.04468 ↩
8. Microsoft Research. "Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks." https://www.microsoft.com/en-us/research/articles/magentic-one-a-generalist-multi-agent-system-for-solving-complex-tasks/ ↩
9. Microsoft Azure Blog. "Introducing Microsoft Agent Framework." October 2025. https://azure.microsoft.com/en-us/blog/introducing-microsoft-agent-framework/ ↩
10. Visual Studio Magazine. "Semantic Kernel + AutoGen = Open-Source 'Microsoft Agent Framework'." October 1, 2025. https://visualstudiomagazine.com/articles/2025/10/01/semantic-kernel-autogen--open-source-microsoft-agent-framework.aspx ↩
11. VentureBeat. "Microsoft retires AutoGen and debuts Agent Framework to unify and govern enterprise AI agents." https://venturebeat.com/ai/microsoft-retires-autogen-and-debuts-agent-framework-to-unify-and-govern ↩
12. AG2AI. "AG2 (formerly AutoGen): The Open-Source AgentOS." https://github.com/ag2ai/ag2 ↩
13. DEV Community. "Microsoft Autogen Has Split in 2... Wait 3... No, 4 Parts." https://dev.to/maximsaplin/microsoft-autogen-has-split-in-2-wait-3-no-4-parts-2p58 ↩
14. Microsoft Learn. "AutoGen to Microsoft Agent Framework Migration Guide." https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/ ↩
15. AutoGen Documentation. "AgentChat User Guide." https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/index.html ↩
16. AutoGen Documentation. "Migration Guide for v0.2 to v0.4." https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/migration-guide.html ↩
17. AutoGen Documentation. "Teams." https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/teams.html ↩
18. AutoGen 0.2 Documentation. "Multi-agent Conversation Framework." https://microsoft.github.io/autogen/0.2/docs/Use-Cases/agent_chat/ ↩
19. InfoQ. "Microsoft Research AI Frontiers Lab Launches AutoGen v0.4 Library." January 2025. https://www.infoq.com/news/2025/01/microsoft-autogen-040/ ↩
20. Victor Dibia. "A Friendly Introduction to AutoGen Studio (v0.4)." https://newsletter.victordibia.com/p/autogen-studio-v04-a-no-code-tool ↩
21. DataCamp. "CrewAI vs LangGraph vs AutoGen: Choosing the Right Multi-Agent AI Framework." https://www.datacamp.com/tutorial/crewai-vs-langgraph-vs-autogen ↩
22. Visual Studio Magazine. "Microsoft Ships Production-Ready Agent Framework 1.0 for .NET and Python." April 6, 2026. https://visualstudiomagazine.com/articles/2026/04/06/microsoft-ships-production-ready-agent-framework-1-0-for-net-and-python.aspx ↩