---
title: New AutoGen Architecture Preview
authors:
  - autogen-team
tags: [AutoGen]
---

# New AutoGen Architecture Preview

<center>

![What are they doing?](img/robots.jpeg)

</center>

One year ago, we launched AutoGen, a programming framework designed to build
agentic AI systems. The release of AutoGen sparked massive interest within the
developer community. As an early release, it provided us with a unique
opportunity to engage deeply with users, gather invaluable feedback, and learn
from a diverse range of use cases and contributions. By listening and engaging
with the community, we gained insights into what people were building or
attempting to build, how they were approaching the creation of agentic systems,
and where they were struggling. This experience was both humbling and
enlightening, revealing significant opportunities for improvement in our initial
design, especially for power users developing production-level applications with
AutoGen.

Through engagements with the community, we learned many lessons:

- Developers value modular and reusable agents. For example, our built-in agents
  that could be directly plugged in or easily customized for specific use cases
  were particularly popular. At the same time, there was a desire for more
  customizability, such as integrating custom agents built using other
  programming languages or frameworks.
- Chat-based agent-to-agent communication was an intuitive collaboration
  pattern, making it easy for developers to get started and involve humans in
  the loop. As developers began to employ agents in a wider range of scenarios,
  they sought more flexibility in collaboration patterns. For instance,
  developers wanted to build predictable, ordered workflows with agents, and to
  integrate them with new user interfaces that are not chat-based.
- Although it was easy for developers to get started with AutoGen, debugging and
  scaling agent teams applications proved more challenging.
- There were many opportunities for improving code quality.

These learnings, along with many others from other agentic efforts across
Microsoft, prompted us to take a step back and lay the groundwork for a new
direction. A few months ago, we started dedicating time to distilling these
learnings into a roadmap for the future of AutoGen. This led to the development
of AutoGen 0.4, a complete redesign of the framework from the foundation up.
AutoGen 0.4 embraces the actor model of computing to support distributed, highly
scalable, event-driven agentic systems. This approach offers many advantages,
such as:

- **Composability**. Systems designed in this way are more composable, allowing
  developers to bring their own agents implemented in different frameworks or
  programming languages and to build more powerful systems using complex agentic
  patterns.
- **Flexibility**. It allows for the creation of both deterministic, ordered
  workflows and event-driven or decentralized workflows, enabling customers to
  bring their own orchestration or integrate with other systems more easily. It
  also opens more opportunities for human-in-the-loop scenarios, both active and
  reactive.
- **Debugging and Observability**. Event-driven communication moves message delivery
  away from agents to a centralized component, making it easier to observe and
  debug their activities regardless of agent implementation.
- **Scalability**. An event-based architecture enables distributed and
  cloud-deployed agents, which is essential for building scalable AI services
  and applications.

Today, we are delighted to share our progress and invite everyone to collaborate
with us and provide feedback to evolve AutoGen and help shape the future of
multi-agent systems.

As the first step, we are opening a [pull request](https://github.com/microsoft/autogen/pull/3600) into the main branch with the
current state of development of 0.4. After approximately a week, we plan to
merge this into main and continue development. There's still a lot left to do
before 0.4 is ready for release though, so keep in mind this is a work in
progress.

Starting in AutoGen 0.4, the project will have three main libraries:

- **Core** - the building blocks for an event-driven agentic system.
- **AgentChat** - a task-driven, high-level API built with core, including group
  chat, code execution, pre-built agents, and more. This is the most similar API
  to AutoGen [0.2](https://github.com/microsoft/autogen/tree/0.2) and will be the easiest API to migrate to.
- **Extensions** - implementations of core interfaces and third-party integrations
  (e.g., Azure code executor and OpenAI model client).

AutoGen [0.2](https://github.com/microsoft/autogen/tree/0.2) is still available, developed and maintained out of the [0.2 branch](https://github.com/microsoft/autogen/tree/0.2).
For everyone looking for a stable version, we recommend continuing to use [0.2](https://github.com/microsoft/autogen/tree/0.2)
for the time being. It can be installed using:

```sh
pip install autogen-agentchat~=0.2
```

This new package name was used to align with the new packages that will come with 0.4:
`autogen-core`, `autogen-agentchat`, and `autogen-ext`.

Lastly, we will be using [GitHub
Discussion](https://github.com/microsoft/autogen/discussions) as the official
community forum for the new version and, going forward, all discussions related
to the AutoGen project. We look forward to meeting you there.
