Autogen Agents

Overview

AutoGen is a framework for building multi-agent conversation systems. Agents chat with each other to solve tasks, with built-in code execution, tool use, and human-in-the-loop patterns.

Capabilities

• Create conversational agents with specific roles
• Enable code execution in sandboxed environments
• Build group chats with multiple agents
• Integrate function calling and tool use
• Support human-in-the-loop via UserProxyAgent
• Use nested conversations for complex workflows

When to Use

Trigger phrases:

• "autogen agents"

• "AutoGen multi-agent conversations — AssistantAgent, UserProxyAgent, group chat, "

• Building conversational AI systems with multiple perspectives

• Needing agents that write and execute code

• Wanting human oversight in agent conversations

• Building research, coding, or analysis teams

When NOT to Use

• Task is outside your authorization scope
• You need to implement controls (use implementing-* skills)
• Task is about analysis, not action (use analyzing-* skills)
• You don't have access to target systems
• Task requires compliance expertise (consult professionals)
• Task is about defense, not offense (use defensive skills)

Pseudo Code

# Example workflow for this skill
def execute(input_data):
    # Step 1: Validate input
    if not input_data:
        raise ValueError("Input data is required")

    # Step 2: Process core logic
    result = process(input_data)

    # Step 3: Validate output
    validate_output(result)

    return result

Basic Two-Agent Chat

from autogen import AssistantAgent, UserProxyAgent, config_list_from_json

config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST")

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

user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",  # AUTO, ALWAYS, or NEVER
    max_consecutive_auto_reply=10,
    code_execution_config={"work_dir": "coding", "use_docker": True},
)

user_proxy.initiate_chat(assistant, message="Write a Python script to analyze sales data.")

Group Chat

from autogen import GroupChat, GroupChatManager

coder = AssistantAgent(
    name="Coder",
    system_message="You write Python code. Always include complete, runnable code.",
    llm_config={"config_list": config_list},
)

reviewer = AssistantAgent(
    name="Reviewer",
    system_message="You review code for bugs, security issues, and improvements.",
    llm_config={"config_list": config_list},
)

planner = AssistantAgent(
    name="Planner",
    system_message="You plan the approach and break tasks into steps.",
    llm_config={"config_list": config_list},
)

user_proxy = UserProxyAgent(
    name="User",
    human_input_mode="TERMINATE",
    code_execution_config={"work_dir": "output"},
)

group_chat = GroupChat(
    agents=[user_proxy, planner, coder, reviewer],
    messages=[],
    max_round=20,
    speaker_selection_method="auto",  # or "round_robin", "random"
)

manager = GroupChatManager(groupchat=group_chat, llm_config={"config_list": config_list})

user_proxy.initiate_chat(manager, message="Build a REST API for task management.")

Function Calling

from autogen import register_function

def get_weather(city: str) -> str:
    """Get current weather for a city."""
    return f"Weather in {city}: 72°F, Sunny"

register_function(
    get_weather,
    caller=assistant,
    executor=user_proxy,
    name="get_weather",
    description="Get current weather for a city",
)

Nested Conversations

def writing_callback(recipient, messages, sender, config):
    """Check if writing meets criteria."""
    last_message = messages[-1]
    if "APPROVED" in last_message["content"]:
        return True, last_message["content"]
    return False, "Please revise and include APPROVED when done."

nested_assistant = AssistantAgent(
    name="nested_writer",
    llm_config={"config_list": config_list},
)

nested_assistant.register_nested_conversation(
    trigger=planner,
    recipient=nested_assistant,
    message="Write the technical documentation.",
    summary_method="last_msg",
    max_turns=5,
)

Common Patterns

Error Handling

How to Use

1. Invoke the skill when relevant domain keywords appear in the request
2. Provide required inputs as specified in the skill definition
3. Review the output for correctness before delivering to the user
4. Combine with related skills for complex multi-step workflows

Verification

After completing this skill, confirm:

• Output meets the defined quality and completeness requirements
• All prerequisites are verified and documented
• Error handling covers edge cases
• Results are accurate and actionable

Process

1. Analyze the task requirements
2. Apply domain expertise
3. Verify output quality

Anti-Rationalization Table