# AutoGen — Open-source Microsoft framework for building single and multi-agent AI applications in Python.

> Source: The Agents Index — https://theagentsindex.com/microsoft-autogen (structured, researched, re-verified)
> Facts last verified: 2026-09-19

AutoGen is an open-source Microsoft framework for building single- and multi-agent AI applications in Python, layered as Core, AgentChat and Extensions. Microsoft has placed it in maintenance mode and points new projects to its successor, Microsoft Agent Framework.

| Fact | Value |
| --- | --- |
| Website | https://microsoft.github.io/autogen/stable/ |
| Price | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction |
| Free tier | Yes |

The entire framework, including AutoGen Studio, is MIT-licensed and installable from PyPI at no cost; the only spend is your own model provider's inference bill.

## What it does

**Writes code** · Yes — Ships a dedicated coder agent whose system prompt specialises it for writing code and creating artifacts, used inside Magentic-One teams alongside a terminal agent.

> Coder: This is an LLM-based agent specialized through its system prompt for writing code, analyzing information collected from the other agents, or creating new artifacts.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/magentic-one.html · Architecture section, agent list, Coder bullet

**Debugs and fixes** · Partly — Microsoft describes iterative troubleshooting through tool use and code execution, but documents no claim that it diagnoses and lands a fix in an existing repository unattended.

> Enables effective coding-related tasks, like tool use with back-and-forth troubleshooting.
> — https://github.com/microsoft/autogen/blob/main/TRANSPARENCY_FAQS.md · What can AutoGen do? section, benefits list

**Reviews code** · Partly — The reflection design pattern pairs a coder agent with a reviewer agent that critiques the generated code; no surface reviews a diff or pull request someone else wrote.

> For example, given a task to write code, the first LLM can generate a code snippet, and the second LLM can generate a critique of the code snippet.
> — https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/design-patterns/reflection.html · Reflection design pattern page, opening paragraph

**Whole-codebase work** · Partly — FileSurfer navigates directories and reads local files while the executors run commands in a work_dir, so file-by-file work is possible; no repository indexing or repo-wide migration is documented.

> The FileSurfer can also perform common navigation tasks such as listing the contents of directories and navigating a folder structure.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/magentic-one.html · Magentic-One page, Architecture section, FileSurfer bullet

**Ships it** · Partly — A team can execute the code it writes in a shell or Docker container, but nothing in the docs claims it opens pull requests or deploys to an environment.

> ComputerTerminal: Finally, ComputerTerminal provides the team with access to a console shell where the Coder's programs can be executed, and where new programming libraries can be installed.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/magentic-one.html · Architecture section, agent list, ComputerTerminal bullet

**Done-for-you service** · No — This is software you install and run yourself as Python packages; Microsoft offers no build-and-run service here, and the project is now community managed.

> AutoGen is now in maintenance mode. It will not receive new features or enhancements and is community managed going forward.
> — https://github.com/microsoft/autogen · README, Maintenance Mode caution block

_Not established: Writes tests_

## How much it does unattended

**Runs autonomously** · Yes — Microsoft states agents can act autonomously, and the Magentic-One orchestrator plans, delegates and self-reflects until a task completes without a human turn.

> AutoGen is a framework for creating multi-agent AI applications that can act autonomously or work alongside humans.
> — https://github.com/microsoft/autogen · README, opening description under the AutoGen heading

**Multi-agent** · Yes — Coordination of several agents is the core design: a lead orchestrator decomposes tasks and assigns subtasks to web, file, coder and terminal agents.

> Orchestrator: the lead agent responsible for task decomposition and planning, directing other agents in executing subtasks, tracking overall progress, and taking corrective actions as needed
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/magentic-one.html · Architecture section, agent list, Orchestrator bullet

**Agent permissions** · Partly — Permission gating is something the developer wires in: a user proxy agent can be inserted for approvals, and the guidance is that users confirm code before execution, but there is no policy engine.

> Human involvement: AutoGen prioritizes human involvement in multi agent conversation. The overseers can step in to give feedback to agents and steer them in the correct direction. In all examples, users confirm code before it is executed.
> — https://github.com/microsoft/autogen/blob/main/TRANSPARENCY_FAQS.md · What operational factors and settings allow for effective and responsible use of AutoGen? section

## Which models it runs on

**Claude** · Partly — A first-party Anthropic client exists in the extensions package, but Microsoft labels the section experimental rather than a supported integration.

> To use the AnthropicChatCompletionClient, you need to install the anthropic extra. Underneath, it uses the anthropic python sdk to access the models.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/models.html · Anthropic (experimental) section

**GPT** · Yes — OpenAI is the primary documented model client, installed as an extra, and GPT models are used in nearly every example throughout the guides.

> To access OpenAI models, install the openai extension, which allows you to use the OpenAIChatCompletionClient.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/models.html · OpenAI section, first paragraph

**Open models** · Partly — Open-weight models run through the Ollama client or OpenAI-compatible endpoints, but that client is marked experimental and Microsoft warns local models are less capable.

> Ollama is a local model server that can run models locally on your machine.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/models.html · Ollama (experimental) section

**Model choice** · Yes — You choose the model per agent, and Microsoft states teams can mix heterogeneous models to match capability or cost for different roles.

> Magentic-One is model agnostic and can incorporate heterogonous models to support different capabilities or meet different cost requirements when getting tasks done.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/magentic-one.html · Architecture section, closing paragraph on model choice

## Where you use it

**In your editor** · No — The documented surfaces are the Python and .NET libraries plus two developer tools, Studio and Bench; no IDE or editor extension is offered.

> AutoGen Studio provides a no-code GUI for building multi-agent applications.
> — https://github.com/microsoft/autogen · README, Why AutoGen? section, developer tools list — the only two entries are Studio and AutoGen Bench

**On the command line** · Partly — A built-in Console UI streams a run to the terminal and UserProxyAgent can take console input, but there is no standalone agent CLI; the autogenstudio command only launches the web UI.

> The Console() method provides a convenient way to print messages to the console with proper formatting.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/teams.html · Teams tutorial, Observing a Team section

**In a browser** · Yes — AutoGen Studio provides a browser-based low-code interface for building and running teams, though Microsoft calls it a prototyping tool, not a production app.

> AutoGen Studio is a low-code interface built to help you rapidly prototype AI agents, enhance them with tools, compose them into teams and interact with them to accomplish tasks.
> — https://microsoft.github.io/autogen/stable/user-guide/autogenstudio-user-guide/index.html · AutoGen Studio page, opening paragraph

_Not established: In your pipeline_

## Whose machine it runs on

**Self-hosted** · Yes — Everything runs on your own machines: agents execute in your process, and a gRPC host plus worker runtimes let you distribute them across your own infrastructure.

> A distributed agent runtime facilitates communication and agent lifecycle management across process boundaries. It consists of a host service and at least one worker runtime.
> — https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/framework/distributed-agent-runtime.html · Distributed Agent Runtime page, opening paragraphs

**Open source** · Yes — The code is published under the MIT licence in the microsoft/autogen repository, granting use, modification and redistribution without fee.

> MIT License Copyright (c) Microsoft Corporation. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
> — https://github.com/microsoft/autogen/blob/main/LICENSE-CODE · LICENSE-CODE file, opening lines

## What it costs to run

**How it meters** · Partly — The framework itself carries no meter at all; your only spend is whatever your chosen model provider bills against the API key you supply.

> The following samples call OpenAI API, so you first need to create an account and export your key as export OPENAI_API_KEY="sk-...".
> — https://github.com/microsoft/autogen · README, Quickstart section introduction

**Free tier** · Yes — No account, sales call or payment is involved: the packages install from PyPI under an MIT licence granted free of charge.

> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction
> — https://github.com/microsoft/autogen/blob/main/LICENSE-CODE · LICENSE-CODE file, permission grant paragraph

**API access** · Yes — It is itself a programming interface you import into your own stack, with layered Python packages for core runtime, agent teams and extensions.

> A programming framework for building conversational single and multi-agent applications. Built on Core. Requires Python 3.10+.
> — https://microsoft.github.io/autogen/stable/ · Home page, AgentChat card

**MCP server** · Partly — AutoGen consumes MCP servers as agent tools through McpWorkbench, but the docs do not describe exposing an AutoGen agent as an MCP server another agent could query.

> McpWorkbench for using Model-Context Protocol (MCP) servers.
> — https://microsoft.github.io/autogen/stable/ · Home page, Extensions card, built-in extensions list

**Bring your own key** · Yes — You bring your own inference throughout: your OpenAI key, your Azure deployment and AAD identity, or a local Ollama server on your own hardware.

> To use the client, you need to provide your deployment id, Azure Cognitive Services endpoint, api version, and model capabilities. For authentication, you can either provide an API key or an Azure Active Directory (AAD) token credential.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/models.html · Azure OpenAI section

## Buying it for a team

**Admin controls** · Partly — Constraints are developer-level: the runtime enforces identity and privacy boundaries, code executes in a Docker sandbox, and an approval callback can gate each execution. There is no admin console or policy engine.

> the framework provides a runtime environment, which facilitates communication between agents, manages their identities and lifecycles, and enforce security and privacy boundaries
> — https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/core-concepts/architecture.html · Agent Runtime Environments page, opening paragraph

**Audit log** · Partly — Runtime events including model calls are emitted through Python logging for you to capture, but this is application telemetry rather than a tamper-evident administrative audit trail.

> AutoGen uses standard Python logging module to log events like model calls and responses. The logger name is autogen_core.EVENT_LOGGER_NAME, and the event type is LLMCall.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/models.html · Log Model Calls section

**Single sign-on** · No — No identity integration ships anywhere in the project; Microsoft explicitly tells developers to implement authentication themselves when building on the framework.

> It is not meant to be a production-ready app. Developers are encouraged to use the AutoGen framework to build their own applications, implementing authentication, security and other features required for deployed applications.
> — https://microsoft.github.io/autogen/stable/user-guide/autogenstudio-user-guide/index.html · AutoGen Studio page, Caution block above Capabilities

## What happens to your code

**Getting out** · Yes — Teams, agents and conditions serialise to JSON via dump_component and save_state, and Studio persists sessions in your own SQLite or PostgreSQL database. No credits exist to expire.

> State is a dictionary that can be serialized to a file or written to a database.
> — https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/state.html · Managing State tutorial, Persisting State (File or Database) section

_Not established: Certifications_

## Platform record (as of 2026-08-30)

Reported by the code-hosting platform, not by the vendor.

| Fact | Value |
| --- | --- |
| Licence | CC-BY-4.0 |
| Stars | 60699 |
| Forks | 9164 |
| Last push | 2026-04-15 |

## Provenance

5 of 19 sources behind the facts above are independent of the vendor.

## Coverage elsewhere

Pages about this product that the vendor does not control. The label states how independent each one is.

| Source | Kind | Read |
| --- | --- | --- |
| github.com | Platform record | 2026-08-23 |
| github.com | Platform record | 2026-08-23 |
| devblogs.microsoft.com | A competitor's comparison | 2026-07-21 |
| visualstudiomagazine.com | Independent source | 2026-07-21 |
| github.com | Platform record | 2026-08-23 |
| github.com | Platform record | 2026-08-23 |

## What changed

- 2026-09-19 — Capabilities · Commercial terms · Free tier · Price
- 2026-09-02 — Capabilities · Commercial terms · Free tier
- 2026-09-01 — Website
- 2026-08-31 — Capabilities · Commercial terms · Free tier
- 2026-08-23 — Alternatives · One-liner · Summary

## Correcting this record

Anything marked "Not established" is a question we have not answered — it is not a No. If you represent AutoGen, or anything here is wrong or out of date, you can supply it with a source: the operations this site accepts from an agent are listed at https://theagentsindex.com/.well-known/agents.json — that catalogue needs no key to read, and each entry states its own auth.

Supplying evidence is free. Nothing that can be bought here changes what a field says, whether a gap is closed, or how this record is scored.