New AutoGen Architecture Preview

[jackgerrits]

Blog post

Please use discussion for feedback, comments, or questions.

---

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 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 this pull request 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 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).

Core

The core API of AutoGen is built following the actor model. It supports asynchronous message passing between agents and event-based workflows. Start here if you are building scalable, event-driven agentic systems. Agents in the core layer handle and produce typed messages, using either direct messaging, which functions like RPC, or via broadcasting to topics, which is pub-sub. Agents can be distributed and implemented in different programming languages, while still communicating with one another.

AgentChat

AgentChat API is task driven and at a high level like AutoGen 0.2. It allows you to define conversational agents, compose them into teams, and then use them to solve tasks. AgentChat itself is built on the core layer, but it abstracts away much of its low-level system concepts. Start here if you just want to focus on multi-agents and workflows while not worrying about scalability and deep integration with existing software. For workflows that don’t fit into the API provided by AgentChat, target just core instead.

Extensions

The extension package contains implementations of the core interfaces using third-party systems, such as OpenAI model client and Azure code executors. Besides the built-in extensions, the package accommodates community-contributed extensions through namespace sub-packages. We are looking forward to seeing your contributions.

AutoGen 0.2

AutoGen 0.2 is still available, developed and maintained out of the 0.2 branch. For everyone looking for a stable version, we recommend continuing to use 0.2 for the time being. It can be installed using:

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

- AutoGen Team