How do I correctly format the `config_list` to use different LLMs with AutoGen agents?

The `config_list` in AutoGen is a list of dictionaries, each specifying an LLM configuration including the model name, API key, and optionally other parameters like base URL or API type for different providers.

How do AutoGen agents communicate with each other?

AutoGen agents communicate by sending messages to each other. These messages contain content (text, code, instructions) and are processed sequentially, driving the conversation flow and task progression.

What are the different `human_input_mode` options for `UserProxyAgent` and when should I use them?

`human_input_mode` controls when the `UserProxyAgent` solicits input from a human. 'ALWAYS' prompts for every turn, 'NEVER' allows full autonomy, and 'TERMINATE' asks only when the agents believe the task is complete.

Back/AI Agents

AutoGen's Core Agents: AssistantAgent, UserProxyAgent, and Communication Fundamentals

AutoGen

By Anuj SharmaJuly 22, 2026 • 3 MIN READ

The Brief

AutoGen's foundational agents, the AssistantAgent and UserProxyAgent, enable collaborative AI by facilitating LLM-driven reasoning, human interaction, and basic task execution. They communicate through message passing, configured via a flexible config_list to integrate diverse Large Language Models.

Action Checklist

Set up your config_list with at least one LLM provider (e.g., OpenAI, Azure, or a local model via Ollama).
Instantiate an AssistantAgent with a clear system_message defining its role.
Instantiate a UserProxyAgent, configuring its human_input_mode and code_execution_config.
Initiate a simple chat between your UserProxyAgent and AssistantAgent to test basic communication.
Experiment with different system_message prompts for the AssistantAgent to observe changes in behavior.

Key Takeaways

The AssistantAgent and UserProxyAgent are the foundational agents in AutoGen, enabling LLM-driven intelligence and human/tool interaction.
Effective agent communication relies on clear message passing and well-defined roles set via system_message.
AutoGen's config_list provides a flexible mechanism to integrate and manage diverse Large Language Models.
Proper configuration of UserProxyAgent's human_input_mode and code_execution_config is crucial for control and security.
Mastering these core building blocks is the essential first step towards creating sophisticated multi-agent systems.

Having explored the foundational concepts of AI agents and the architectural overview of AutoGen in previous chapters, we now transition from theory to practical implementation. This chapter introduces the two core agents that form the backbone of almost every AutoGen application: the AssistantAgent and the UserProxyAgent. Understanding these agents, how to configure them, and critically, how they communicate, is paramount to building any functional multi-agent system within AutoGen. This knowledge empowers you to begin constructing sophisticated AI workflows, laying the groundwork for integrating tools and advanced collaboration patterns.

What Is It?

This chapter defines the AssistantAgent as AutoGen's primary LLM-driven AI agent, responsible for generating responses, code, and plans based on its configured Large Language Model. It also defines the UserProxyAgent as the crucial interface for human users, capable of receiving human input, executing code, and acting as a proxy for external tools. Together, these agents form a basic conversational loop, exchanging messages to achieve a common goal, with their intelligence powered by configurable LLMs.

Why It Matters

The AssistantAgent and UserProxyAgent are the atomic units of interaction within AutoGen. Mastering their configuration and communication is essential because they are the fundamental building blocks upon which all more complex multi-agent systems are constructed. Without a deep understanding of these core components, designing effective collaborative AI workflows, integrating tools, or orchestrating sophisticated group chats (topics for future chapters) becomes impossible. They provide the basic intelligence and interaction capabilities necessary for autonomous task completion and human-AI collaboration.

When to Use It

Use the AssistantAgent whenever you need an LLM to perform reasoning, generate content, write code, or answer questions autonomously. Employ the UserProxyAgent when you require human input, want to execute generated code (e.g., Python scripts), or need to use external tools or functions. Configure LLMs using config_list when integrating different models (e.g., OpenAI's GPT-4, Azure OpenAI, local models via Ollama) or when switching between models for cost-effectiveness or specific capabilities. These agents are the starting point for any AutoGen project, from simple chatbots to complex automated development environments.

Prerequisites

Chapter 1: Foundational Concepts of AI Agents and Multi-Agent Systems(understanding agent characteristics and MAS benefits).
Chapter 2: Introduction to Microsoft AutoGen(familiarity with AutoGen's purpose, architecture, and basic installation).

Step-by-Step Framework

Ensure AutoGen is installed: Verify your Python environment has autogen-agentchat installed (pip install autogen-agentchat).

Define your LLM configuration: Create a config_list dictionary specifying your LLM provider, model, and API key. For example, config_list = [{'model': 'gpt-4', 'api_key': 'YOUR_OPENAI_API_KEY'}].

Instantiate the AssistantAgent: Create an instance of AssistantAgent, providing a name and your config_list. Optionally, define a system_message to set its persona and instructions.

Instantiate the UserProxyAgent: Create an instance of UserProxyAgent, providing a name. Configure human_input_mode ('ALWAYS', 'NEVER', 'TERMINATE') and code_execution_config (e.g., {'policy': 'auto', 'use_docker': False} or {'use_docker': True, 'docker_image': 'python:3-slim'}).

Initiate the conversation: Use the initiate_chat() method from UserProxyAgent, targeting the AssistantAgent, and provide an initial message or task description.

Observe and interact: Monitor the conversation in your console. If human_input_mode is 'ALWAYS', provide input when prompted. If 'NEVER', the agents will attempt to complete the task autonomously.

Best Practices

Craft clear and concise system_message for AssistantAgent to define its role, goals, and constraints, guiding its behavior effectively.

Always consider security for UserProxyAgent's code execution; prefer use_docker=True for untrusted code to isolate the environment.

Manage LLM costs and performance by strategically using config_list to prioritize cheaper or faster models for simpler tasks and powerful models for complex ones.

Start with human_input_mode='ALWAYS' for UserProxyAgent during development to understand agent interactions and debug effectively.

Iteratively refine agent prompts and configurations; small adjustments to system_message or code_execution_config can significantly alter agent performance.

Common Mistakes

Incorrect config_list format: Ensure the config_list is a list of dictionaries, each containing 'model' and 'api_key' (or appropriate fields for other providers).

Missing API keys or incorrect environment variables: Double-check that your LLM API keys are correctly set and accessible to AutoGen.

Unintended code execution: Failing to configure code_execution_config properly can lead to local execution of potentially malicious or erroneous code.

Undefined agent roles: Without a clear system_message, agents may exhibit generic behavior or struggle to understand their specific task within a conversation.

Agent looping: Agents can get stuck in repetitive cycles if termination conditions are not clear or if one agent continuously asks for clarification without progress.

Recommended Tools & Resources

OpenAI API: For access to powerful models like GPT-4 and GPT-3.5-turbo, directly integrated into AutoGen via config_list.
Azure OpenAI Service: For enterprise-grade LLM deployments with enhanced security and compliance features, also configurable through config_list.
Ollama: For running open-source Large Language Models (LLMs) like Llama 2 or Mistral locally on your machine, integrating with AutoGen as a local endpoint.
Hugging Face: For accessing a vast array of open-source models that can be integrated with AutoGen, often requiring specific API wrappers or local serving.

Frequently Asked Questions

The `AssistantAgent` is an LLM-powered agent designed for reasoning, generation, and problem-solving, whereas the `UserProxyAgent` acts as a human proxy, handling user input, code execution, and tool calls.

Related Dispatches

Personal Brand

The Future of Personal Branding: Innovation & Ethical Considerations in the AI Age

Personal Brand

Advanced Personal Branding Frameworks: Scaling & Monetizing Your Influence

Next ChapterIn Chapter 4, we will enhance our agents' capabilities by integrating external tools and mastering code execution. You'll learn how AutoGen agents leverage custom functions and execute code in secure environments to extend their problem-solving prowess beyond their inherent LLM capabilities.

Action Checklist

Set up your config_list with at least one LLM provider (e.g., OpenAI, Azure, or a local model via Ollama).

Instantiate an AssistantAgent with a clear system_message defining its role.

Instantiate a UserProxyAgent, configuring its human_input_mode and code_execution_config.

Initiate a simple chat between your UserProxyAgent and AssistantAgent to test basic communication.

Experiment with different system_message prompts for the AssistantAgent to observe changes in behavior.

Key Takeaways

The AssistantAgent and UserProxyAgent are the foundational agents in AutoGen, enabling LLM-driven intelligence and human/tool interaction.

Effective agent communication relies on clear message passing and well-defined roles set via system_message.

AutoGen's config_list provides a flexible mechanism to integrate and manage diverse Large Language Models.

Proper configuration of UserProxyAgent's human_input_mode and code_execution_config is crucial for control and security.

Mastering these core building blocks is the essential first step towards creating sophisticated multi-agent systems.