AutoGen

AutoGen's conversation model

Most frameworks wire agents together with function calls and shared state. AutoGen takes a different approach: agents communicate entirely through natural language messages, like a group chat. Each agent receives messages, decides whether to respond or pass, and sends natural language back.

This makes AutoGen feel more like coordination between humans: the UserProxy (representing you) sends a task, the AssistantAgent responds with a plan or code, you (or the proxy) provide feedback, and the cycle continues until the task is complete. The conversation history is the shared state.

Two-agent setup

pip install pyautogen

import autogen

# Configuration for Anthropic models
config_list = [
    {
        "model": "claude-3-5-sonnet-20241022",
        "api_key": "your-anthropic-api-key",
        "api_type": "anthropic",
    }
]

llm_config = {"config_list": config_list, "temperature": 0}

# AssistantAgent: the AI that does the work
assistant = autogen.AssistantAgent(
    name="Assistant",
    llm_config=llm_config,
    system_message="You are a helpful AI assistant. When writing code, make it runnable."
)

# UserProxyAgent: represents the user, can execute code
user_proxy = autogen.UserProxyAgent(
    name="User",
    human_input_mode="NEVER",       # "NEVER", "TERMINATE", or "ALWAYS"
    max_consecutive_auto_reply=5,   # auto-reply up to 5 times
    is_termination_msg=lambda x: "TERMINATE" in x.get("content", ""),
    code_execution_config={
        "work_dir": "./workspace",
        "use_docker": False,        # set True for isolated execution
    }
)

# Start the conversation
user_proxy.initiate_chat(
    assistant,
    message="Write a Python function that finds all prime numbers up to N using the Sieve of Eratosthenes, then test it with N=50."
)

Group chat with multiple agents

import autogen

config_list = [{"model": "claude-3-5-sonnet-20241022", "api_key": "...", "api_type": "anthropic"}]
llm_cfg = {"config_list": config_list}

# Define specialist agents
coder = autogen.AssistantAgent(
    name="Coder",
    system_message="You write clean Python code. After writing, say LGTM when done.",
    llm_config=llm_cfg,
)
reviewer = autogen.AssistantAgent(
    name="Reviewer",
    system_message="You review code for bugs, edge cases, and style. Be critical. Say LGTM when approved.",
    llm_config=llm_cfg,
)
executor = autogen.UserProxyAgent(
    name="Executor",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": ".", "use_docker": False},
    is_termination_msg=lambda x: "LGTM" in x.get("content", "") and "Reviewer" in x.get("name", "")
)

# Group chat — agents take turns responding
groupchat = autogen.GroupChat(
    agents=[executor, coder, reviewer],
    messages=[],
    max_round=10,
    speaker_selection_method="auto"   # LLM decides who speaks next
)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=llm_cfg)

executor.initiate_chat(manager, message="Write and test a function that checks if a string is a palindrome.")

Code execution agent

AutoGen's killer feature: the UserProxyAgent can automatically execute code that the AssistantAgent writes, return the output, and continue the conversation. This enables a full code-write-run-debug loop:

user_proxy = autogen.UserProxyAgent(
    name="User",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "./workspace",     # where code files are saved
        "use_docker": True,            # RECOMMENDED: Docker for safe execution
        "timeout": 60,                 # kill runaway processes after 60s
        "last_n_messages": 3,          # only extract code from last 3 messages
    },
    is_termination_msg=lambda msg: msg.get("content") and "TERMINATE" in msg["content"]
)
# The assistant writes code → UserProxy executes it → returns stdout/stderr
# → assistant sees the output and fixes bugs → repeat

Always use Docker in production. use_docker=False executes code directly on your machine. A hallucinated os.remove call could delete files. Docker provides sandboxed, isolated execution.

Human-in-the-loop

user_proxy = autogen.UserProxyAgent(
    name="User",
    human_input_mode="TERMINATE",   # ask human when agent wants to terminate
    # Options:
    # "NEVER"    — fully autonomous, never asks for human input
    # "TERMINATE" — asks human only when agent sends termination message
    # "ALWAYS"   — asks human for input at every turn
    max_consecutive_auto_reply=3,   # auto-reply 3 times, then ask human
)

# With "TERMINATE" mode: the agent works autonomously until it says TERMINATE,
# then prompts you to review and either provide feedback or accept the result.

TERMINATE mode is the sweet spot for production: fully autonomous for routine steps, but pauses for human review before finalising important outputs.

AutoGen with Anthropic

import autogen

# Anthropic configuration
config_list_anthropic = [
    {
        "model": "claude-3-5-sonnet-20241022",
        "api_key": "your-anthropic-api-key",
        "api_type": "anthropic",
        "max_tokens": 4096
    }
]

# Use Haiku for less critical agents
config_list_haiku = [
    {
        "model": "claude-3-5-haiku-20241022",
        "api_key": "your-anthropic-api-key",
        "api_type": "anthropic",
    }
]

# Mix models: expensive model for planner, cheap for executors
planner = autogen.AssistantAgent(
    name="Planner",
    llm_config={"config_list": config_list_anthropic, "temperature": 0},
    system_message="You decompose tasks into clear subtasks."
)
worker = autogen.AssistantAgent(
    name="Worker",
    llm_config={"config_list": config_list_haiku, "temperature": 0},
    system_message="You execute tasks precisely as specified."
)

Gotchas

max_consecutive_auto_reply is critical. Without it, two agents can loop indefinitely (each responding to the other). Always set a limit. The is_termination_msg function is the graceful exit; max_consecutive_auto_reply is the emergency stop.

Group chat speaker selection can be unpredictable. With speaker_selection_method="auto", an LLM decides who speaks next. This can produce unexpected turn orders. For deterministic pipelines, use "round_robin" or a custom selection function.

Conversation history grows with every message. In long group chats, the accumulated conversation becomes very large and expensive. Configure last_n_messages in code execution config to limit what the agent sees, or periodically summarise the conversation.

Code execution is off by default in newer versions. AutoGen 0.4+ changed defaults. If code isn't executing, check your code_execution_config and ensure the work directory exists and has write permissions.