# AutoGen: features, protocols, quickstart

## TL;DR

AutoGen is Microsoft's Python and .NET framework for multi-agent applications built from conversing agents, group-chat teams and an event-driven core runtime. It is in maintenance mode: no new features, community managed, and Microsoft points new users to Microsoft Agent Framework. It mainly suits teams maintaining existing AutoGen code.

## Key facts

| Field | Value |
| --- | --- |
| Type | Framework |
| Languages / SDKs | Python, .NET |
| License | CC-BY-4.0 |
| Pricing model | Open source, free |
| Orchestration pattern | Blackboard |
| GitHub stars | 61,246 (as of 2026-10-01) |
| GitHub forks | 9,275 |
| Last push | 2026-04-15 |
| Latest release | python-v0.7.5 |
| Repository | [microsoft/autogen](https://github.com/microsoft/autogen) |
| Website | [microsoft.github.io](https://microsoft.github.io/autogen/) |
| Documentation | [microsoft.github.io](https://microsoft.github.io/autogen/stable/) |
| Last verified | 2026-09-30 |

## Key features

- Layered packages: Core (event-driven agents and runtime), AgentChat (high-level agents and teams) and Extensions (model clients, code execution, tools). ([source](https://github.com/microsoft/autogen/blob/main/README.md))
- Team presets: `RoundRobinGroupChat`, `SelectorGroupChat` (a model picks the next speaker), `MagenticOneGroupChat` and `Swarm`. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html))
- `Swarm` teams where agents pass control with `HandoffMessage` instead of a central selector. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/swarm.html))
- `GraphFlow`, a team that follows a directed graph with sequential, parallel, conditional and looping steps (marked experimental). ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/graph-flow.html))
- MCP tools through `McpWorkbench` in `autogen_ext.tools.mcp`, for example a Playwright MCP server over stdio. ([source](https://github.com/microsoft/autogen/blob/main/README.md))
- `save_state()` / `load_state()` on agents and teams for persisting a conversation between requests. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html))
- A `Memory` protocol with a simple `ListMemory` implementation for injecting stored facts into model context. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/memory.html))
- AutoGen Studio, a no-code GUI for prototyping multi-agent workflows. ([source](https://github.com/microsoft/autogen/blob/main/README.md))

## Architecture and orchestration pattern

Pattern: Blackboard.

The Python codebase is split into three layers. `autogen-core` is an event-driven, actor-style runtime where agents exchange messages and can run locally or across processes; it also has a .NET implementation. `autogen-agentchat` sits on top and provides ready-made agents (`AssistantAgent`, `UserProxyAgent`, `CodeExecutorAgent`) and teams. `autogen-ext` holds model clients, code executors and tool integrations such as MCP.

The main multi-agent model in AgentChat is a group chat: participants share one conversation and a policy decides who speaks next (fixed rotation, a model-based selector, handoff messages in `Swarm`, or the Magentic-One orchestrator). Termination conditions such as text mentions, token limits or handoffs end a run. `GraphFlow` adds an explicit directed-graph workflow on the same team interface.

State is held in memory during a run. Agents and teams expose `save_state()` and `load_state()` so an application can store and restore them, and the `Memory` protocol lets an agent pull stored items into its context. There is no built-in durable execution layer.

### Human in the loop

The AgentChat tutorial describes two approaches. During a run, a `UserProxyAgent` participates in the team and asks for input through a configurable `input_func` (console `input()` by default, or an async function wired to a web UI); while it waits, the whole team is blocked, so the docs advise using it only for short exchanges. Between runs, the team stops on a termination condition such as `max_turns`, `TextMentionTermination` or `HandoffTermination`, and the user's reply is passed as the next task; the team keeps its context. `ExternalTermination` and cancellation tokens let application code stop a run from outside. The docs link sample integrations for FastAPI, ChainLit and Streamlit.

## Protocols

| Protocol | Support | Evidence | Note |
| --- | --- | --- | --- |
| MCP | Yes (checked 2026-09-30) | [link](https://github.com/microsoft/autogen/blob/main/README.md) | Client: `McpWorkbench` and `StdioServerParams` from `autogen_ext.tools.mcp` give an `AssistantAgent` the tools of an MCP server (README example uses the Playwright MCP server). |
| A2A | Unknown (checked 2026-09-30) | — | Not in AutoGen's README or AgentChat docs; repo code search found no A2A implementation, only an open, unmerged community pull request (#6669). The README mentions A2A only for Microsoft Agent Framework. |
| AG-UI | Unknown (checked 2026-09-30) | — | Searched README, AgentChat docs and repo code for 'ag-ui'/'ag_ui' with no hits; the AG-UI README lists AG2 but not AutoGen. |

## Best for

- Maintaining or extending an existing AutoGen 0.4+ codebase before a planned migration
- Experimenting with group-chat, selector and Magentic-One style teams in research settings ([shortlist](https://multiagentguide.top/best/research-agents.md))
- Prototyping multi-agent workflows visually with AutoGen Studio on a local machine ([shortlist](https://multiagentguide.top/best/self-hosted-local.md))

## Not for

- New projects that need new features or long-term vendor support; Microsoft directs these to Microsoft Agent Framework
- Workflows that require durable, resumable execution without writing your own state storage
- Deploying AutoGen Studio as a user-facing production app, which the README says it is not meant for

## Quickstart

```sh
pip install -U "autogen-agentchat" "autogen-ext[openai]"
```

Install verified 2026-09-30 (uv venv, Python 3.12.13, macOS arm64: `uv pip install -U autogen-agentchat autogen-ext[openai]` ok, `from autogen_agentchat.agents import AssistantAgent` ok, autogen-agentchat 0.7.5. Packages came from the mirrors.aliyun.com mirror, so the version is the one that mirror served on this date. Install and import check only; not a functional test.).

```python
import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    client = OpenAIChatCompletionClient(model="gpt-4.1")  # reads OPENAI_API_KEY
    writer = AssistantAgent("writer", model_client=client,
                            system_message="Draft a two-line product blurb.")
    critic = AssistantAgent("critic", model_client=client,
                            system_message="Critique the draft. Say APPROVE when it is good.")
    team = RoundRobinGroupChat([writer, critic], max_turns=6,
                               termination_condition=TextMentionTermination("APPROVE"))
    result = await team.run(task="Blurb for a solar-powered kettle")
    print(result.messages[-1].content)
    await client.close()

asyncio.run(main())
```

### Common pitfalls

- Python 3.10 or later is required.
- The README samples call the OpenAI API and expect `OPENAI_API_KEY` to be exported.
- The 0.4+ packages (`autogen-agentchat`, `autogen-core`, `autogen-ext`) are a rewrite; code written for AutoGen 0.2 must follow the migration guide.
- The project is in maintenance mode, so fixes are limited to bugs, security patches and docs; check the date of the latest release before depending on it.
- Only connect to trusted MCP servers; the README warns they can run commands locally.

Official quickstart: https://github.com/microsoft/autogen/blob/main/README.md

## Pros

- Can be used at different levels, from the high-level AgentChat API down to the event-driven Core runtime. ([source](https://github.com/microsoft/autogen/blob/main/README.md))
- Several team strategies are available out of the box, from round-robin to model-selected speakers and Magentic-One. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html))
- MCP servers can be attached to an agent with a few lines via `McpWorkbench`. ([source](https://github.com/microsoft/autogen/blob/main/README.md))
- Agents and teams can be serialized with `save_state()` and restored later, which suits stateless web endpoints. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html))
- Code is MIT-licensed (`LICENSE-CODE`); no paid tier is attached to it. ([source](https://github.com/microsoft/autogen/blob/main/LICENSE-CODE))

## Cons

- In maintenance mode: no new features, community managed, contributions limited to fixes and docs; Microsoft recommends Microsoft Agent Framework instead. ([source](https://github.com/microsoft/autogen/blob/main/README.md))
- The latest Python release on GitHub is python-v0.7.5, published 2025-09-30. ([source](https://github.com/microsoft/autogen/releases/tag/python-v0.7.5))
- `GraphFlow`, the structured workflow option, is labelled experimental. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/graph-flow.html))
- A `UserProxyAgent` blocks the whole team while waiting for input, so the docs limit it to short interactions. ([source](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/human-in-the-loop.html))
- AutoGen Studio is explicitly not meant to be a production application. ([source](https://github.com/microsoft/autogen/blob/main/README.md))

## Alternatives

- [Microsoft Agent Framework](https://multiagentguide.top/tools/microsoft-agent-framework.md) ([AutoGen vs Microsoft Agent Framework](https://multiagentguide.top/compare/microsoft-agent-framework-vs-autogen.md))
- [AG2](https://multiagentguide.top/tools/ag2.md) ([AutoGen vs AG2](https://multiagentguide.top/compare/ag2-vs-autogen.md))
- [Semantic Kernel](https://multiagentguide.top/tools/semantic-kernel.md)
- [CrewAI](https://multiagentguide.top/tools/crewai.md)
- [LangGraph](https://multiagentguide.top/tools/langgraph.md)

## FAQ

### Is AutoGen still maintained?

Only in maintenance mode. The README says it gets no new features, is community managed, and accepts bug fixes, security patches and docs changes. New users are pointed to Microsoft Agent Framework.

### Does AutoGen support MCP?

Yes, as a client. `McpWorkbench` in `autogen-ext` connects an agent to an MCP server's tools. No A2A or AG-UI support was found in the official repo or docs.

### What license is AutoGen under?

GitHub reports CC-BY-4.0 because the main LICENSE file covers documentation. The code is under the MIT License in LICENSE-CODE.

### How is AutoGen different from AG2?

AutoGen is Microsoft's repository, rewritten in 0.4 into Core, AgentChat and Extensions, now in maintenance mode. AG2 is a separate, community-run project that diverged from the AutoGen codebase in November 2024 and has since moved to its own async API.

### What should I migrate to?

Microsoft publishes an AutoGen to Microsoft Agent Framework migration guide and recommends that framework for new projects.

## Sources

- [AutoGen GitHub repository](https://github.com/microsoft/autogen)
- [AutoGen documentation (stable)](https://microsoft.github.io/autogen/stable/)
- [AutoGen README (maintenance-mode notice, install, MCP example)](https://github.com/microsoft/autogen/blob/main/README.md)
- [AgentChat installation (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/installation.html)
- [AgentChat quickstart (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/quickstart.html)
- [Teams tutorial (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html)
- [Human-in-the-loop tutorial (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/human-in-the-loop.html)
- [Managing state (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html)
- [Memory and RAG (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/memory.html)
- [SelectorGroupChat (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/selector-group-chat.html)
- [Swarm (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/swarm.html)
- [GraphFlow (AutoGen docs)](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/graph-flow.html)
- [AutoGen releases](https://github.com/microsoft/autogen/releases)
- [AutoGen python-v0.7.5 release](https://github.com/microsoft/autogen/releases/tag/python-v0.7.5)
- [Migration guide: AutoGen to Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-autogen/)
- [AutoGen LICENSE-CODE (MIT)](https://github.com/microsoft/autogen/blob/main/LICENSE-CODE)
- [AutoGen LICENSE (CC-BY-4.0, documentation)](https://github.com/microsoft/autogen/blob/main/LICENSE)
- [Open pull request: A2A support (#6669)](https://github.com/microsoft/autogen/pull/6669)
- [AG-UI README, supported integrations](https://github.com/ag-ui-protocol/ag-ui/blob/main/README.md)
- [AG2 overview: relationship to AutoGen (AG2 docs)](https://docs.ag2.ai/docs/user-guide/motivation/)

## Unknown fields

protocols.a2a: searched README, AgentChat docs and GitHub code search (`a2a`, `agent2agent` in microsoft/autogen); only an open community PR (#6669) exists, no merged support or official statement. protocols.agui: searched README, docs and code search (`ag-ui`, `ag_ui`) with no results; AutoGen is not in the AG-UI integrations list.

Corrections or removal requests: support@multiagentguide.top

---

Data as of 2026-10-01. Not affiliated with listed projects. HTML version: https://multiagentguide.top/tools/autogen