AG2 (AutoGen Evolved)

AG2 provides four distinct collaboration patterns — swarms for parallel task distribution, sequential chains for pipeline workflows, group chats with LLM-based automatic speaker selection for multi-party collaboration, and nested conversations for hierarchical agent compositions. The GroupChatManager coordinates turn-taking and routing, while developers can customize speaker selection logic, termination conditions, and maximum turn limits for each pattern.

AG2 uniquely bridges agent ecosystems by connecting agents built in CrewAI, LangChain, LlamaIndex, and other frameworks into unified conversations through standardized A2A and MCP protocols. This cross-framework orchestration means teams are not locked into a single agent framework — they can leverage the best tools from each ecosystem while AG2's AgentOS runtime handles message routing, state synchronization, and lifecycle management across heterogeneous agent populations.

The UserProxyAgent class provides granular control over human involvement in agent conversations. Developers configure human_input_mode to ALWAYS (human approves every message), TERMINATE (human intervenes only at conversation end), or NEVER (fully autonomous). The agent can relay messages to humans, execute code on their behalf, and seamlessly transition between autonomous operation and human oversight at any conversation turn.

Agents can write, execute, and iteratively debug Python code within sandboxed environments. AG2 supports LocalCommandLineCodeExecutor for development, DockerCommandLineCodeExecutor for production-safe isolation, and Jupyter-based execution for notebook-style workflows. Configurable timeouts, allowed languages, and working directories give developers control over the execution environment while preventing runaway processes.

Register any Python function as an agent tool with automatic schema generation using simple decorators. The @register_for_llm decorator exposes a tool to an agent's LLM for function calling, while @register_for_execution designates which agent runs the function. This separation of calling and execution enables secure patterns where one agent decides to use a tool but a different, authorized agent performs the action. LangChain tool adapters provide additional interoperability.

Built-in RAG capabilities allow agents to ingest, index, and reason over external documents during conversations. The RetrieveUserProxyAgent handles document chunking, embedding generation, and vector store queries (with native ChromaDB support and adapters for Pinecone and Weaviate). Agents automatically retrieve relevant passages and inject them as context, enabling document-grounded conversations without requiring separate RAG infrastructure.

Every agent inherits from the ConversableAgent base class, providing a unified interface for sending and receiving messages, maintaining conversation history, and registering reply functions. This architecture means any agent can talk to any other agent, conversations are composable (a two-agent chat can be nested inside a group chat), and new agent types are created by subclassing and overriding reply logic rather than implementing complex interfaces.

AG2 integrates with all major LLM providers — OpenAI GPT-4 and GPT-4o, Anthropic Claude, Google Gemini, Mistral, Azure OpenAI, and local open-weight models via Ollama and LM Studio. Different agents in the same conversation can use different models, enabling cost optimization by routing simple tasks to cheaper models while reserving expensive frontier models for complex reasoning. Model failover chains automatically switch providers if a primary model is unavailable.

Define strict output schemas using Pydantic models, enforce JSON response formats, and set precise termination conditions to maintain control over agent conversations. Developers can specify max_turns limits, custom termination keywords, reply function overrides, and conversation hooks that trigger at specific points in the dialogue flow. This ensures agent conversations produce machine-parseable results and terminate predictably.

The shared state system provides a centralized context store accessible to all agents in a conversation. In sequential chats, the carryover mechanism automatically passes relevant context from one conversation stage to the next. Context variables can be set, read, and updated by any participating agent, enabling coordination without requiring agents to explicitly pass information through conversation messages. AgentOS extends this with persistent state across sessions.