autogen

Implements a unified agent abstraction (ConversableAgent) that handles bidirectional message passing, reply function composition, and state management across heterogeneous agent types. Uses a pluggable reply function registry pattern where agents register handlers for different message types, enabling dynamic behavior composition without inheritance chains. Agents maintain conversation history, manage turn-taking logic, and support both synchronous and asynchronous message exchange through a standardized interface.

Orchestrates multi-agent conversations where 3+ agents participate in a shared chat context. Implements a speaker selection mechanism that determines which agent speaks next based on eligibility policies (rules that filter which agents can respond to specific messages). Uses a GroupChat object that maintains shared conversation history and applies policies like round-robin, relevance-based selection, or custom predicates. Supports nested chats where a group chat can be invoked as a single turn in another conversation.

Implements comprehensive logging and tracing for agent execution using Python's logging module and OpenTelemetry. Captures agent messages, function calls, LLM requests/responses, and execution timing. Integrates with OpenTelemetry for distributed tracing, enabling visualization of agent execution flows across multiple services. Supports structured logging with JSON output for log aggregation systems.

Implements integration with the Model Context Protocol (MCP), a standardized protocol for tools and resources. Agents can discover and invoke MCP-compatible tools without custom integration code. Supports both local MCP servers and remote MCP endpoints. Implements automatic schema translation between MCP tool definitions and agent function calling interfaces.

Implements the A2A (Agent-to-Agent) protocol, a standardized message format for agent communication. Provides an AG-UI adapter that enables agents to communicate through a web-based UI. Supports both direct agent-to-agent communication and communication through a central UI server. Implements message serialization and deserialization for the A2A protocol.

Provides a command-line interface for creating, configuring, and managing AG2 projects. Supports project scaffolding with templates, configuration management, and local development workflows. Implements commands for running agents, managing dependencies, and deploying agent systems. Integrates with the AG2 documentation and examples.

Implements an experimental beta agent framework that uses middleware and observer patterns for extensibility. Agents can register middleware that intercepts and modifies messages before/after processing. Observers can subscribe to agent lifecycle events (message received, response generated, etc.). Supports both synchronous and asynchronous middleware/observers.

Implements DocumentAgent, a specialized agent type for analyzing and synthesizing information from multiple documents. Automatically chunks documents, creates embeddings, and retrieves relevant sections for analysis. Supports both single-document and cross-document analysis. Implements automatic summarization and synthesis of information across documents.

Provides a unified client interface (OpenAIWrapper and ModelClient V2) that abstracts away provider-specific API differences for OpenAI, Anthropic, Gemini, Ollama, and other LLM providers. Agents configure LLM behavior through a config_list (list of model configurations) that specifies model names, API keys, parameters, and fallback strategies. Implements automatic provider detection, request marshaling to provider-specific formats, and response normalization to a UnifiedResponse format that all agents consume uniformly.

Enables agents to invoke external functions and APIs through a schema-based function registry. Agents register Python functions with JSON schema descriptions, and the LLM generates function calls that are validated against schemas and executed with automatic type coercion. Implements dependency injection for tools, allowing functions to receive context (agent state, conversation history) without explicit parameter passing. Supports both synchronous and asynchronous function execution.

Provides a sandboxed code execution environment where agents can write and run Python code. Uses Jupyter kernels as the execution backend, enabling stateful code execution where variables persist across multiple code blocks. Implements code validation, output capture, and error handling. Supports both local execution and remote kernel connections. Integrates with the code generation pipeline to execute generated code and provide feedback to agents.

Implements SwarmAgent, a specialized agent type that dynamically routes tasks to other agents based on message content and agent capabilities. Uses a routing function that examines incoming messages and selects the most appropriate agent to handle the request. Supports hierarchical routing where a swarm agent can delegate to other swarm agents. Implements automatic context propagation so agents in the swarm have access to shared state and conversation history.

Enables agents to receive and process LLM responses as they stream in, rather than waiting for complete responses. Implements streaming clients for OpenAI Realtime API and Google Gemini Realtime API that handle audio/text input and output. Agents can process partial responses incrementally, enabling lower-latency interactions and more responsive behavior. Supports both text and audio modalities for input and output.

Implements RetrieveChat, an agent type that augments conversations with retrieved documents from vector databases. Before responding, the agent retrieves relevant documents based on the user query, then uses those documents as context for generating responses. Supports multiple vector database backends (Chroma, Weaviate, Pinecone) through a pluggable retrieval interface. Implements query expansion and re-ranking to improve retrieval quality.

Implements Graph RAG, an advanced retrieval approach that builds knowledge graphs from documents and retrieves information by traversing graph edges. Instead of vector similarity, Graph RAG uses graph structure to find related entities and relationships. Supports both local graph construction and integration with external knowledge graphs. Implements multi-hop reasoning where agents traverse multiple edges to answer complex questions.

Implements ContextVariables, a mechanism for sharing state across agents in a group chat or multi-agent system. Context variables are key-value pairs that agents can read and write, enabling coordination without explicit message passing. Supports variable scoping (global, group-level, agent-level) and change notifications so agents can react to state updates. Implements automatic serialization for complex state objects.