AutoGen by Microsoft: Conversable Agents and Group Chat Patterns

AutoGen's Core Idea

AutoGen, developed by Microsoft Research, is built around a single powerful abstraction: conversable agents. Every agent in AutoGen can send and receive messages to other agents. The framework models multi-agent collaboration as conversations — agents literally talk to each other, and the conversation transcript becomes the shared context.

This design choice is intentional. Instead of rigid pipelines or predefined workflows, AutoGen lets agents negotiate, debate, and iteratively refine their outputs through natural language dialogue. The result is a framework that handles open-ended, exploratory tasks particularly well.

Conversable Agents

The ConversableAgent is AutoGen's foundational class. Every agent type — assistant agents, user proxies, and custom agents — inherits from it. A conversable agent has three key capabilities: it can generate replies using an LLM, execute code, and interact with humans.

flowchart LR
    USER(["UserProxyAgent"])
    subgraph CHAT["GroupChat"]
        C1["Coder agent"]
        C2["Reviewer agent"]
        C3["Executor agent<br/>Docker sandbox"]
    end
    MGR["GroupChatManager<br/>next speaker selection"]
    OUT(["Termination<br/>stop word reached"])
    USER --> MGR --> C1 --> MGR
    MGR --> C2 --> MGR
    MGR --> C3 --> MGR
    MGR --> OUT
    style MGR fill:#4f46e5,stroke:#4338ca,color:#fff
    style C3 fill:#ede9fe,stroke:#7c3aed,color:#1e1b4b
    style OUT fill:#059669,stroke:#047857,color:#fff

from autogen import ConversableAgent

# A simple conversable agent
assistant = ConversableAgent(
    name="Assistant",
    system_message="""You are a helpful AI assistant.
    Solve tasks carefully and explain your reasoning.""",
    llm_config={"model": "gpt-4o", "temperature": 0},
)

# A user proxy that can execute code
user_proxy = ConversableAgent(
    name="UserProxy",
    human_input_mode="NEVER",  # Fully autonomous
    code_execution_config={
        "work_dir": "coding_output",
        "use_docker": False,
    },
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
)

The human_input_mode parameter controls how much human oversight the agent requires. NEVER means fully autonomous, ALWAYS asks for human input at every step, and TERMINATE only asks when the conversation is about to end.

Two-Agent Conversations

The simplest AutoGen pattern is a two-agent conversation. One agent generates solutions, the other validates or executes them:

# Start a conversation between two agents
user_proxy.initiate_chat(
    assistant,
    message="""Write a Python function that finds the longest
    palindromic substring in a given string. Include test cases.""",
)

When this runs, the assistant generates Python code, the user proxy executes it in a sandboxed environment, and the result is sent back to the assistant. If the code fails, the assistant sees the error and iterates. This loop continues until the task succeeds or hits the termination condition.

Group Chat: Multi-Agent Collaboration

AutoGen's group chat is where the framework truly differentiates itself. You can put multiple agents in a shared conversation where they take turns contributing:

from autogen import GroupChat, GroupChatManager

# Define specialized agents
coder = ConversableAgent(
    name="Coder",
    system_message="""You write Python code to solve problems.
    Always include type hints and docstrings.""",
    llm_config={"model": "gpt-4o"},
)

reviewer = ConversableAgent(
    name="Reviewer",
    system_message="""You review code for bugs, edge cases,
    and performance issues. Be thorough but constructive.""",
    llm_config={"model": "gpt-4o"},
)

tester = ConversableAgent(
    name="Tester",
    system_message="""You write comprehensive test cases.
    Cover edge cases, boundary conditions, and error scenarios.""",
    llm_config={"model": "gpt-4o"},
)

executor = ConversableAgent(
    name="Executor",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "output", "use_docker": False},
    is_termination_msg=lambda msg: "ALL_TESTS_PASSED" in msg.get("content", ""),
)

# Create group chat
group_chat = GroupChat(
    agents=[coder, reviewer, tester, executor],
    messages=[],
    max_round=12,
    speaker_selection_method="auto",
)

manager = GroupChatManager(
    groupchat=group_chat,
    llm_config={"model": "gpt-4o"},
)

# Kick off the group conversation
executor.initiate_chat(
    manager,
    message="Build a thread-safe LRU cache in Python with TTL support.",
)

The speaker_selection_method="auto" lets the GroupChatManager use an LLM to decide which agent should speak next based on the conversation context. The coder writes the implementation, the reviewer critiques it, the tester writes tests, and the executor runs everything.

Code Execution Safety

AutoGen supports Docker-based code execution for sandboxing. In production, always enable this:

code_execution_config = {
    "work_dir": "output",
    "use_docker": "python:3.11-slim",
    "timeout": 60,
}

This runs all generated code inside a Docker container, preventing agents from modifying the host system. The timeout parameter kills long-running code that might be stuck in an infinite loop.

Conversation Patterns Beyond Group Chat

AutoGen supports several conversation patterns. Sequential chat chains conversations so the output of one becomes the input of the next. Nested chat lets an agent spawn a sub-conversation with other agents to answer a specific question before returning to the main conversation.

# Nested chat: agent consults sub-agents for specific questions
assistant.register_nested_chats(
    [
        {
            "recipient": fact_checker,
            "message": "Verify these claims",
            "max_turns": 3,
        }
    ],
    trigger=lambda sender: "fact check" in sender.last_message().get("content", "").lower(),
)

When to Choose AutoGen

AutoGen is strongest for iterative, code-heavy workflows where agents need to write, execute, debug, and refine code collaboratively. The built-in code execution and conversation-based architecture make it natural for coding assistants, data analysis pipelines, and research tasks.

It is less suited for simple tool-calling agents or production APIs where you need deterministic, low-latency responses. The conversation overhead adds latency, and the autonomous nature makes outputs less predictable.

FAQ

How does AutoGen handle infinite conversation loops?

AutoGen has multiple safeguards: the max_round parameter on GroupChat limits conversation turns, is_termination_msg functions detect completion signals, and you can set max_consecutive_auto_reply on individual agents to cap their responses.

Can AutoGen agents use external tools beyond code execution?

Yes. You can register functions as tools on any ConversableAgent using register_for_llm() and register_for_execution(). These work like OpenAI function calling — the agent decides when to invoke them.

Is AutoGen suitable for production web APIs?

AutoGen is designed more for batch processing and complex reasoning tasks than for low-latency API endpoints. For production APIs, consider wrapping AutoGen workflows in async task queues rather than running them synchronously in request handlers.

---

#AutoGen #Microsoft #MultiAgentSystems #GroupChat #CodeExecution #AgenticAI #LearnAI #AIEngineering