AG2 (formerly AutoGen)

Learning Objectives

• Understand the AG2 / AutoGen split and what it means for developers
• Identify AG2's core concepts: conversable agents, group chat, and code execution
• Compare AG2 vs. CrewAI and LangGraph for different multi-agent use cases

What Is AG2?

AG2 ("The Open-Source AgentOS") is a community-governed multi-agent framework originally created by Microsoft Research as AutoGen in September 2023. AutoGen became one of the most cited AI agent papers of the year, pioneering the idea that complex AI tasks are best accomplished through multi-agent conversations — AI agents that talk to each other, critique each other's work, and converge on better solutions through dialogue.

In November 2024, the original creators forked the project as AG2 at ag2.ai, moving to independent, community-driven governance. The project retains AutoGen's core architecture while continuing active development under the AG2 banner.

Core Concepts

Conversable Agents

AG2's fundamental building block is the ConversableAgent — an agent that can send and receive messages in a conversation:

from ag2 import AssistantAgent, UserProxyAgent

config_list = [{"model": "gpt-4o", "api_key": "your-key"}]

assistant = AssistantAgent(
    name="Assistant",
    llm_config={"config_list": config_list},
    system_message="You are a helpful AI assistant."
)

user_proxy = UserProxyAgent(
    name="User",
    human_input_mode="NEVER",  # or "ALWAYS" or "TERMINATE"
    max_consecutive_auto_reply=10,
    code_execution_config={"work_dir": "./workspace"}
)

user_proxy.initiate_chat(assistant, message="Analyze the sales data in sales.csv and plot a bar chart")

The UserProxyAgent acts as the human interface and code executor — it runs any code the AssistantAgent produces in a sandboxed working directory and returns the output to continue the conversation.

Conversation Patterns

AG2 implements several conversation patterns:

• Two-agent chat: Human proxy + AI assistant; iterative task completion with code execution
• Group chat: Multiple agents participate in a shared conversation; a GroupChatManager decides who speaks next
• Nested chat: Agent conversations that call other agent conversations as tools

Code Execution — AG2's Signature Feature

AG2's code execution loop is its most distinctive capability:

1. AssistantAgent writes Python code to solve a task
2. UserProxyAgent executes the code in a Docker container or local sandbox
3. Output (success, error, result) is sent back to AssistantAgent
4. AssistantAgent debugs, corrects, and improves the code based on the output
5. Loop continues until the task is complete or the conversation terminates

This self-correcting code loop means AG2 can tackle data analysis, visualization, file processing, and API interaction tasks autonomously.

Group Chat — Multi-Agent Collaboration

For complex tasks requiring multiple perspectives:

from ag2 import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

research_agent = AssistantAgent(name="Researcher", ...)
analyst_agent = AssistantAgent(name="Analyst", ...)
critic_agent = AssistantAgent(name="Critic", ...)

group_chat = GroupChat(
    agents=[user_proxy, research_agent, analyst_agent, critic_agent],
    messages=[],
    max_round=12
)
manager = GroupChatManager(groupchat=group_chat, llm_config={"config_list": config_list})

user_proxy.initiate_chat(manager, message="Analyze market trends for EV adoption in 2025-2026")

The GroupChatManager uses an LLM to decide which agent should respond next — researchers gather facts, analysts draw conclusions, critics identify weaknesses.

AG2 Studio — No-Code Interface

AG2 Studio provides a web interface for building multi-agent workflows without code:

• Visual workflow builder for agent configurations
• Upload files and watch agents process them
• Debug agent conversations step-by-step
• Build reusable agent templates

Comparison: Multi-Agent Frameworks

Pricing

AG2 is free and open source (Apache 2.0 license). Costs are LLM API usage only.

Strengths

• Active community governance: Independent from any single vendor; community-driven roadmap at ag2.ai
• Code execution loop: Best-in-class code writing, execution, and self-correction among open-source frameworks
• Human-in-the-loop: Granular control over when humans are consulted (ALWAYS, NEVER, TERMINATE)
• Group chat flexibility: Manager-directed multi-agent conversations are powerful and expressive
• Docker isolation: Code execution in Docker containers provides safe sandboxing
• Research foundation: Built on one of the most cited AI agent papers; rigorous academic grounding

Limitations & Considerations

• Ecosystem fragmentation: The AutoGen/AG2 split means some tutorials, blog posts, and Stack Overflow answers reference the old pyautogen package — verify you're using the correct import (ag2)
• LLM API costs: Multi-turn conversations consume many tokens — costs can escalate quickly on complex tasks
• Conversation loops: Agents can get stuck in unproductive loops — requires careful max-conversation limits
• Less intuitive than CrewAI: For role-based task workflows, CrewAI's syntax is more readable
• Microsoft ecosystem: Azure OpenAI integration was a strength of the original AutoGen; AG2 maintains it but the Microsoft Agent Framework is now Microsoft's preferred enterprise path

Best Use Cases

When to choose alternatives:

• Simpler role-based pipelines → CrewAI
• Complex stateful graph workflows → LangGraph
• Enterprise Microsoft ecosystem → Microsoft Agent Framework
• Visual no-code automation → n8n or Make

Getting Started

pip install ag2

from ag2 import AssistantAgent, UserProxyAgent

config_list = [{"model": "gpt-4o", "api_key": "YOUR_KEY"}]

assistant = AssistantAgent("assistant", llm_config={"config_list": config_list})
user_proxy = UserProxyAgent("user", human_input_mode="NEVER",
                             code_execution_config={"work_dir": "."})

user_proxy.initiate_chat(assistant,
    message="Write a Python script that fetches the top 5 tech news headlines using a web API and prints them formatted nicely")

Watch the agents exchange messages — the assistant writes code, the proxy executes it and returns output, the assistant debugs and improves.

Key Takeaways

• AG2 (formerly AutoGen) is the community-governed successor to Microsoft Research's pioneering multi-agent framework, with a signature code execution loop that writes, runs, and iterates code automatically
• Microsoft retired AutoGen in early 2026 in favor of the Microsoft Agent Framework; the open-source community continues active development under AG2
• The human-in-the-loop feature (ALWAYS/NEVER/TERMINATE modes) is one of the most granular human oversight implementations in any agent framework
• GroupChat allows multiple specialized agents to collaborate in a shared conversation, directed by a manager agent
• Free and open source (Apache 2.0); costs are LLM API calls only