◆ AI Agent Frameworks

Microsoft AutoGen

python-v0.7.5 open-source

from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="gpt-5",
    reasoning_effort="high",
)
from autogen_agentchat.agents import CodeExecutorAgent

def my_approval(code: str) -> bool:
    print(f"Approve this code?\n{code}")
    return input("[y/n]: ").strip().lower() == "y"

agent = CodeExecutorAgent(
    name="safe_executor",
    code_executor=executor,
    approval_func=my_approval,
)
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="gpt-4o",
    parallel_tool_call=False,
)
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="gpt-4o",
    include_name_in_message=False,
)
from autogen_agentchat.teams import RoundRobinGroupChat, SelectorGroupChat

inner_team = RoundRobinGroupChat([agent_a, agent_b])
outer_team = SelectorGroupChat([inner_team, agent_c], model_client=client)
result = await graph_flow.run(task="Analyze this dataset.")
print(result.stop_reason)  # termination message now lives here, not in result.messages
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.tools import AgentTool

sub_agent = AssistantAgent(name="sub", model_client=model_client)
tool = AgentTool(agent=sub_agent)

main_agent = AssistantAgent(name="main", model_client=model_client, tools=[tool])

async for event in main_agent.run_stream(task="Summarize the report"):
    print(event)
from autogen_agentchat.agents import AssistantAgent

agent = AssistantAgent(
    name="analyst",
    model_client=model_client,
    tools=[search_tool, calculator_tool],
    max_tool_iterations=5,
)
result = await agent.run(task="Find and compute the average price of the top 10 items.")
print(result.messages[-1].content)
from autogen_core.tools import BaseStreamTool
from typing import AsyncGenerator

class MyStreamTool(BaseStreamTool):
    async def run_stream(
        self, args: dict, cancellation_token=None
    ) -> AsyncGenerator[str, None]:
        for chunk in do_work(args["input"]):
            yield chunk
import asyncio

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import MaxMessageTermination
from autogen_agentchat.teams import DiGraphBuilder, GraphFlow
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main():
    model_client = OpenAIChatCompletionClient(model="gpt-4.1-nano")
    agent_a = AssistantAgent("A", model_client=model_client, system_message="You are a helpful assistant.")
    agent_b = AssistantAgent("B", model_client=model_client, system_message="Translate input to Chinese.")
    agent_c = AssistantAgent("C", model_client=model_client, system_message="Translate input to Japanese.")

    builder = DiGraphBuilder()
    builder.add_node(agent_a).add_node(agent_b).add_node(agent_c)
    builder.add_edge(agent_a, agent_b).add_edge(agent_a, agent_c)
    graph = builder.build()

    team = GraphFlow(
        participants=[agent_a, agent_b, agent_c],
        graph=graph,
        termination_condition=MaxMessageTermination(5),
    )

    async for event in team.run_stream(task="Write a short story about a cat."):
        print(event)

asyncio.run(main())
tool = AzureAISearchTool.create_full_text_search(
    name="my_search",
    endpoint="https://<your-service>.search.windows.net",
    index_name="<index>",
    api_key="<key>",
    query_type="semantic"
)
from autogen_agentchat.teams import SelectorGroupChat
from autogen_core.model_context import BufferedChatCompletionContext

team = SelectorGroupChat(
    participants=[agent1, agent2, agent3],
    model_client=model_client,
    model_context=BufferedChatCompletionContext(buffer_size=10)
)
from autogen_agentchat.teams import DiGraphBuilder, GraphFlow

builder = DiGraphBuilder()
builder.add_node(writer).add_node(editor1).add_node(editor2).add_node(final_reviewer)
builder.add_edge(writer, editor1)
builder.add_edge(writer, editor2)
builder.add_edge(editor1, final_reviewer)
builder.add_edge(editor2, final_reviewer)
graph = builder.build()

flow = GraphFlow(
    participants=builder.get_participants(),
    graph=graph,
)
await Console(flow.run_stream(task="Write a short biography of Steve Jobs."))
async with McpWorkbench(server_params) as mcp:
    agent = AssistantAgent(
        "github_assistant",
        model_client=model_client,
        workbench=mcp,
        reflect_on_tool_use=True,
        model_client_stream=True,
    )
    await Console(agent.run_stream(task="Is there a repository named Autogen"))
async with McpWorkbench(StdioServerParams(command="npx", args=["@playwright/mcp@latest", "--headless"])) as mcp:
    agent = AssistantAgent("web_browsing_assistant", model_client=model_client, workbench=mcp)
    team = RoundRobinGroupChat([agent], termination_condition=TextMessageTermination(source="web_browsing_assistant"))
    await Console(team.run_stream(task="Find out how many contributors for the microsoft/autogen repository"))
writer_tool = AgentTool(agent=writer)
assistant = AssistantAgent(
    name="assistant",
    model_client=model_client,
    tools=[writer_tool],
    system_message="You are a helpful assistant.",
)
from autogen_agentchat.agents import CodeExecutorAgent

executor_agent = CodeExecutorAgent(
    name="coder",
    code_executor=executor,
    max_retries_on_error=3,
)
from autogen_agentchat.agents import CodeExecutorAgent

# model_client enables code generation; executor runs the result
agent = CodeExecutorAgent(
    name="coder",
    code_executor=executor,
    model_client=model_client,
)
result = await agent.run(task="Write and run a Python script that prints the first 10 Fibonacci numbers.")
from autogen_agentchat.teams import SelectorGroupChat

team = SelectorGroupChat(
    participants=[agent1, agent2],
    model_client=model_client,
    emit_team_events=True,   # set False to hide SelectorSpeakerEvent etc.
)
async for msg in team.run_stream(task="Analyze this dataset."):
    print(msg)
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.messages import TextMessage
from autogen_agentchat.ui import Console
from autogen_core import CancellationToken
from autogen_core.tools import FunctionTool
from autogen_ext.models.openai import OpenAIChatCompletionClient
from pydantic import BaseModel
from typing import Literal

class AgentResponse(BaseModel):
    thoughts: str
    response: Literal["happy", "sad", "neutral"]

def sentiment_analysis(text: str) -> str:
    return "happy" if "happy" in text else "sad" if "sad" in text else "neutral"

tool = FunctionTool(sentiment_analysis, description="Sentiment Analysis", strict=True)
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
agent = AssistantAgent(
    name="assistant",
    model_client=model_client,
    tools=[tool],
    system_message="Use the tool to analyze sentiment.",
    output_content_type=AgentResponse,
)
await Console(agent.on_messages_stream(
    [TextMessage(content="I am happy today!", source="user")], CancellationToken()
))
{
  "provider": "autogen_agentchat.agents.AssistantAgent",
  "config": {
    "name": "my_agent",
    "stream_model_client": true,
    "model_client": { ... }
  }
}
from autogen_ext.models.llama_cpp import LlamaCppChatCompletionClient
from autogen_core.models import UserMessage
import asyncio

async def main():
    client = LlamaCppChatCompletionClient(
        repo_id="unsloth/phi-4-GGUF", filename="phi-4-Q2_K_L.gguf",
        n_gpu_layers=-1, seed=1337, n_ctx=5000
    )
    result = await client.create([UserMessage(content="Summarize this report", source="user")])
    print(result)

asyncio.run(main())
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.experimental.task_centric_memory import MemoryController
from autogen_ext.experimental.task_centric_memory.utils import Teachability

client = OpenAIChatCompletionClient(model="gpt-4o-2024-08-06")
memory_controller = MemoryController(reset=False, client=client)
teachability = Teachability(memory_controller=memory_controller)

agent = AssistantAgent(
    name="teachable_agent",
    model_client=client,
    memory=[teachability],
)
from autogen_ext.models.ollama import OllamaChatCompletionClient
from autogen_core.models import UserMessage

ollama_client = OllamaChatCompletionClient(model="llama3")
result = await ollama_client.create([UserMessage(content="Summarize this CVE.", source="user")])
print(result)
from autogen_ext.models.ollama import OllamaChatCompletionClient
from autogen_core.models import UserMessage
from pydantic import BaseModel

class ThreatActor(BaseModel):
    name: str
    country: str

ollama_client = OllamaChatCompletionClient(model="llama3", response_format=ThreatActor)
result = await ollama_client.create([UserMessage(content="Identify the threat actor in this report.", source="user")])
print(result)
from autogen_core.tools import FunctionTool

def lookup_weather(city: str) -> str:
    return f"Sunny in {city}"

tool = FunctionTool(lookup_weather, name="lookup_weather", strict=True)
from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools

fetch_mcp_server = StdioServerParams(command="uvx", args=["mcp-server-fetch"])
tools = await mcp_server_tools(fetch_mcp_server)

agent = AssistantAgent(name="fetcher", model_client=model_client, tools=tools, reflect_on_tool_use=True)
from autogen_ext.tools.http import HttpTool

base64_tool = HttpTool(
    name="base64_decode",
    description="base64 decode a value",
    scheme="https",
    host="httpbin.org",
    port=443,
    path="/base64/{value}",
    method="GET",
    json_schema={"type": "object", "properties": {"value": {"type": "string"}}, "required": ["value"]},
)
assistant = AssistantAgent("base64_assistant", model_client=model, tools=[base64_tool])
from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(
    model="gemini-1.5-flash-8b",
    # api_key="GEMINI_API_KEY",
)
from autogen_core.models import UserMessage, ModelFamily
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="deepseek-r1:1.5b",
    api_key="placeholder",
    base_url="http://localhost:11434/v1",
    model_info={"function_calling": False, "json_output": False, "vision": False, "family": ModelFamily.R1},
)
result = await client.create(messages=[UserMessage(content="Is this log line indicative of a brute-force attack?", source="user")])
print("Reasoning:", result.thought)
print("Answer:", result.content)
from functools import partial
from autogen_core.tools import FunctionTool

def query_logs(environment: str, severity: str, keyword: str) -> str:
    return f"Querying {environment} logs for {severity} events matching '{keyword}'"

prod_logs = partial(query_logs, "production", "ERROR")
tool = FunctionTool(prod_logs, description="Query production ERROR logs by keyword.")
print(tool.schema)  # schema only exposes 'keyword'
config = group_chat.dump_component()
with open("team_config.json", "w") as f:
    f.write(config.model_dump_json(indent=4))
state = await group_chat.save_state()
with open("team_state.json", "w") as f:
    f.write(json.dumps(state, indent=4))

# Later, restore the team:
with open("team_config.json", "r") as f:
    config = json.load(f)
group_chat = Team.load_component(config)
with open("team_state.json", "r") as f:
    state = json.load(f)
await group_chat.load_state(state)
from autogen_ext.models.azure import AzureAIChatCompletionClient
from azure.core.credentials import AzureKeyCredential

client = AzureAIChatCompletionClient(
    model="Phi-4",
    endpoint="https://models.inference.ai.azure.com",
    credential=AzureKeyCredential(os.environ["GITHUB_TOKEN"]),
    model_info={"json_output": False, "function_calling": False, "vision": False, "family": "unknown"},
)
result = await client.create([UserMessage(content="Summarize this CVE.", source="user")])
from autogen_ext.models.cache import ChatCompletionCache
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(model="gpt-4o")
cached_client = ChatCompletionCache(client)
result = await cached_client.create([UserMessage(content="What is the capital of France?", source="user")])
print(result.content, result.cached)  # False on first call, True on subsequent identical calls
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.models.cache import ChatCompletionCache, CHAT_CACHE_VALUE_TYPE
from autogen_ext.cache_store.diskcache import DiskCacheStore
from autogen_core.models import UserMessage
from diskcache import Cache
import asyncio

async def main():
    openai_client = OpenAIChatCompletionClient(model="gpt-4o")
    cache_store = DiskCacheStore[CHAT_CACHE_VALUE_TYPE](Cache("/tmp/autogen-cache"))
    cache_client = ChatCompletionCache(openai_client, cache_store)

    response = await cache_client.create([UserMessage(content="Summarise zero-trust networking.", source="user")])
    print(response)  # live response
    response = await cache_client.create([UserMessage(content="Summarise zero-trust networking.", source="user")])
    print(response)  # served from disk cache

asyncio.run(main())
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.graphrag import GlobalSearchTool
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
import asyncio

async def main():
    global_tool = GlobalSearchTool.from_settings(settings_path="./settings.yaml")
    agent = AssistantAgent(
        name="search_assistant",
        tools=[global_tool],
        model_client=OpenAIChatCompletionClient(model="gpt-4o-mini"),
        system_message="Use global_search for broad questions about the dataset.",
    )
    await Console(agent.run_stream(task="What are the main themes across all community reports?"))

asyncio.run(main())
from autogen.agentchat.contrib.capabilities.transform_messages import TransformMessages
from autogen.agentchat.contrib.capabilities.transforms import MessageHistoryLimiter
from autogen import GroupChat, GroupChatManager

transforms = TransformMessages(transforms=[MessageHistoryLimiter(max_messages=10)])

groupchat = GroupChat(
    agents=[agent1, agent2, agent3],
    messages=[],
    speaker_selection_method="auto",
    select_speaker_transform_messages=transforms,
)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)
agent = ConversableAgent(
    name="assistant",
    silent=True,
    llm_config={"config_list": config_list},
)
result = await initiator.a_initiate_chats(chat_queue)
from autogen.coding import DockerCommandLineExecutor

executor = DockerCommandLineExecutor(bind_dir="/host/workspace")
pip install pyautogen[cosmosdb]
retrieve_user_proxy = RetrieveUserProxyAgent(
    name="retrieve_proxy",
    retrieve_config={
        "docs_path": "./docs",
        "context_max_tokens": 2000,
    }
)
{
  "model": "gpt-4",
  "api_type": "azure",
  "api_key": "<your-key>",
  "base_url": "<your-azure-endpoint>",
  "extra_body": {
    "dataSources": [
      {
        "type": "AzureCognitiveSearch",
        "parameters": {
          "endpoint": "<search-endpoint>",
          "key": "<search-key>",
          "indexName": "<index-name>"
        }
      }
    ]
  }
}
user_proxy.initiate_chat(assistant, message="Summarise this doc", max_turns=5)
import autogen

def my_summary(recipient, messages, sender, config):
    return messages[-1]['content'][:200]

autogen.initiate_chats([
    {"sender": agent_a, "recipient": agent_b, "message": "Start task", "summary_method": my_summary},
    {"sender": agent_b, "recipient": agent_c, "message": "Continue",   "summary_method": my_summary},
])
from autogen import filter_config

config_list = [
    {"model": "gpt-4", "api_key": "..."},
    {"model": "gpt-3.5-turbo", "api_key": "..."}
]
filtered = filter_config(config_list, {"model": ["gpt-4"]})
from autogen import ConversableAgent

class MyCustomClient:
    def create(self, params):
        # call your own model endpoint here
        ...
    def message_retrieval(self, response):
        ...
    def cost(self, response):
        ...
    @staticmethod
    def get_usage(response):
        ...

agent = ConversableAgent(
    name='my_agent',
    llm_config={'model': 'my-model', 'model_client_cls': 'MyCustomClient'},
)
agent.register_model_client(model_client_cls=MyCustomClient)
from autogen.agentchat.contrib.society_of_mind_agent import SocietyOfMindAgent
from autogen import GroupChat, GroupChatManager, AssistantAgent, UserProxyAgent

inner_agents = [AssistantAgent('a1', llm_config=llm_config), AssistantAgent('a2', llm_config=llm_config)]
groupchat = GroupChat(agents=inner_agents, messages=[], max_round=6)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

society_agent = SocietyOfMindAgent('society', chat_manager=manager, llm_config=llm_config)
user = UserProxyAgent('user', human_input_mode='NEVER')
user.initiate_chat(society_agent, message='Solve this step by step: ...')
human_proxy.initiate_chat(assistant)
from autogen.agentchat.contrib.gpt_assistant_agent import GPTAssistantAgent

agent = GPTAssistantAgent(
    name="analyst",
    llm_config={"config_list": config_list},
    verbose=True
)
from autogen.agentchat.contrib.qdrant_retrieve_user_proxy_agent import QdrantRetrieveUserProxyAgent

ragent = QdrantRetrieveUserProxyAgent(
    name="qdrant_rag",
    retrieve_config={
        "docs_path": "./docs",
        "collection_name": "my_collection",
    },
)

Summary

Microsoft AutoGen is an open-source Python framework, free to use, for building multi-agent AI applications that act autonomously or alongside humans; it is used as a library imported into your own code, through layers ranging from a no-code Studio UI down to AgentChat for conversational agents and Core for event-driven, distributed multi-agent systems. It suits developers building agentic workflows, MCP or tool-calling integrations, and researchers studying multi-agent collaboration, rather than end users. Its own README positions Microsoft Agent Framework as its enterprise-ready successor, since AutoGen itself is now in maintenance mode, receiving no new features and managed by the community. With 611 contributors and a 2020 first commit it has a long history, but recent activity is limited to 36 commits in the past year, and anyone evaluating it should plan around eventual migration rather than long-term investment.

What Microsoft AutoGen answers

Which model providers can I actually call without writing my own client?

built-in extensions cover OpenAI, Anthropic, Gemini, and Qwen vision-language models, with per-provider options like extended reasoning or adjustable reasoning effort

Does model-generated code run safely on its own?

code execution happens in a Docker container by default, with a user-defined approval step available before anything runs

What does this need in order to run at all?

Python 3.10 or later, installed as separate packages for the conversational layer and any extensions like the OpenAI client

Can agents remember things across a conversation?

agent memory can be backed by Redis or Mem0, storing plain, JSON, or Markdown content instead of holding state only in-process

How much runway does adopting this give me?

none intended going forward — it is in maintenance mode with a named successor and a migration guide, so new work is expected to move off it

Can I see what an agent is doing inside a larger workflow?

tool and sub-agent activity streams as events and is traced through OpenTelemetry, so calls like agent creation and tool execution are observable rather than opaque

all 4 features, with the evidence for each →

Features

4 capabilities · 4 backed by code, an API document or a real run

Built from everything we hold on Microsoft AutoGen — every release we have summarised, its product documentation and how that documentation has changed, its README, its command-line surface and API, and runs we performed ourselves. Dates are when we first saw a capability, not when the vendor introduced it.

Capability area

All capabilities 4 capabilities

Console output formatting verified Supports rich formatted console output as an opt-in display mode. 1 other source · first seen Jan 2025

command line

--rich — Enable rich console output v0.4.4 · Jan 2025 · command-line history

Model configuration verified Accepts a path to a model configuration file to control the underlying model used by the tool. 1 other source · first seen Jan 2025

command line

--model-config — Path to the model configuration file. v0.4.0 · Jan 2025 · command-line history

Markdown file linting verified Checks specified Markdown files for issues. 1 other source · first seen Dec 2024

command line

markdown_files — Markdown files to check. v0.4.0.dev13 · Dec 2024 · command-line history

Human-in-the-loop mode verified Optionally requires human confirmation during tool operation, with the ability to disable it via a flag. 1 other source · first seen Dec 2024

command line

--no-hil — Disable human-in-the-loop mode. v0.4.0.dev12 · Dec 2024 · command-line history

Capability

Evidence

Lines in monospace are the tool's own words — help text parsed from its source, or an endpoint from its API document. Everything else is our summary of a dated release or documentation change, linked back to the source it came from.

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

python-v0.7.5 Sep 30, 2025 · issue -320

AutoGen 0.7.5 adds Anthropic thinking mode, linear memory for RedisMemory, and reasoning_effort for GPT-5 models.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.7.5 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.7.5
```
└──▷ USE IT
Control reasoning depth when calling GPT-5 models to balance latency and answer quality.
python
```
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="gpt-5",
    reasoning_effort="high",
)
```
- ›Adds thinking mode support for the Anthropic client, enabling extended reasoning with Claude models.
- ›Supports linear memory storage in RedisMemory, giving practitioners an alternative memory retrieval strategy.
- ›Adds reasoning_effort parameter support for OpenAI GPT-5 models.
- ›Adds security warnings and defaults to DockerCommandLineCodeExecutor for safer code execution.
python-v0.7.3 Aug 19, 2025 · issue -362

AutoGen 0.7.3 adds GPT-5 model info and extended Pydantic anyOf/oneOf typing support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.7.3 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.7.3
```
- ›Adds model info entry for GPT-5, enabling it to be referenced in AutoGen model configurations.
- ›Extends Pydantic model capability to support anyOf/oneOf item typing for richer schema definitions.
python-v0.7.2 Aug 7, 2025 · issue -363

AutoGen 0.7.2 adds code-execution approval gates, parallel tool call control, JSON/Markdown Redis memory, and safer MagenticOne defaults.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.7.2 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.7.2
```
└──▷ USE IT
Gate code execution in an automated pipeline by prompting a human reviewer before any generated code runs.
python
```
from autogen_agentchat.agents import CodeExecutorAgent

def my_approval(code: str) -> bool:
    print(f"Approve this code?\n{code}")
    return input("[y/n]: ").strip().lower() == "y"

agent = CodeExecutorAgent(
    name="safe_executor",
    code_executor=executor,
    approval_func=my_approval,
)
```
Disable parallel tool calls on an OpenAI client to avoid race conditions when using AgentTool or TeamTool.
python
```
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="gpt-4o",
    parallel_tool_call=False,
)
```
- ›Adds approval_func option to CodeExecutorAgent, enabling a user-defined callback to approve or reject code before execution.
- ›Adds parallel_tool_call configuration to the OpenAI model client config, letting callers control whether tools are invoked in parallel.
- ›Supports JSON and MARKDOWN content types in Redis agent memory, expanding storage format flexibility.
- ›Makes DockerCommandLineCodeExecutor the default code executor for the MagenticOne team, improving isolation out of the box.
└──▷ BREAKING ON UPGRADE
- !Assistant-related methods have been removed from OpenAIAssistantAgent (OpenAIAgent); callers relying on those methods will break on upgrade.
python-v0.7.1 Jul 28, 2025 · issue -364

AutoGen 0.7.1 adds RedisMemory, nested Team participants, OpenAI built-in tools, and expanded MCP Workbench support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.7.1 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.7.1
```
└──▷ USE IT
Suppress the name field in OpenAI messages when targeting models or proxies that reject it.
python
```
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="gpt-4o",
    include_name_in_message=False,
)
```
Compose multi-team workflows by nesting a specialist Team as a participant in a parent GroupChat.
python
```
from autogen_agentchat.teams import RoundRobinGroupChat, SelectorGroupChat

inner_team = RoundRobinGroupChat([agent_a, agent_b])
outer_team = SelectorGroupChat([inner_team, agent_c], model_client=client)
```
- ›Adds RedisMemory extension class for persistent, Redis-backed agent memory.
- ›Enables nested Team instances as participants inside another Team (e.g., in a GroupChat).
- ›Expands OpenAIAgent to support all OpenAI built-in tools.
- ›Adds include_name_in_message parameter to make the name field optional in chat messages sent via the OpenAI client.
- ›Expands MCP Workbench to support more MCP client features with the latest MCP version.
+2 moreshow less
- ›Adds timeout support for HTTP tools.
- ›Adds support for "format": "json" in JSON schemas.
python-v0.6.4 Jul 9, 2025 · issue -364

AutoGen 0.6.4 adds reflection for Claude in AssistantAgent, Workbench tool-name overrides, and Qwen2.5VL support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.4 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.6.4
```
└──▷ USE IT
Read the termination reason from GraphFlow without relying on a _StopAgent message in the conversation.
python
```
result = await graph_flow.run(task="Analyze this dataset.")
print(result.stop_reason)  # termination message now lives here, not in result.messages
```
- ›Enables GraphFlow to resume with a new or empty task after a termination condition without an explicit reset, matching the behavior of RoundRobinGroupChat and SelectorGroupChat.
- ›Adds tool name and description override support to McpWorkbench and StaticWorkbench, allowing client-side customization of server-side tool metadata.
- ›Adds reflection support for Claude models in AssistantAgent.
- ›Adds Qwen2.5VL vision-language model support.
└──▷ BREAKING ON UPGRADE
- !In GraphFlow, the inner _StopAgent is removed and no longer emits a final message; code that reads a stop message from the last agent message must be updated to read TaskResult.stop_reason instead.
python-v0.6.2 Jul 1, 2025 · issue -364

AutoGen v0.6.2 adds streaming tools, inner tool-call loops, OTel GenAI traces, Mem0 memory, and a tool_choice parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.2 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.6.2
```
└──▷ USE IT
Receive streamed inner events from a sub-agent tool while running a top-level AssistantAgent — useful for real-time visibility into delegated work.
python
```
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.tools import AgentTool

sub_agent = AssistantAgent(name="sub", model_client=model_client)
tool = AgentTool(agent=sub_agent)

main_agent = AssistantAgent(name="main", model_client=model_client, tools=[tool])

async for event in main_agent.run_stream(task="Summarize the report"):
    print(event)
```
Limit how many back-to-back tool calls AssistantAgent may make before returning, preventing runaway loops in automated pipelines.
python
```
from autogen_agentchat.agents import AssistantAgent

agent = AssistantAgent(
    name="analyst",
    model_client=model_client,
    tools=[search_tool, calculator_tool],
    max_tool_iterations=5,
)
result = await agent.run(task="Find and compute the average price of the top 10 items.")
print(result.messages[-1].content)
```
Create a custom streaming tool that yields intermediate results as it executes, so callers can observe progress via run_stream.
python
```
from autogen_core.tools import BaseStreamTool
from typing import AsyncGenerator

class MyStreamTool(BaseStreamTool):
    async def run_stream(
        self, args: dict, cancellation_token=None
    ) -> AsyncGenerator[str, None]:
        for chunk in do_work(args["input"]):
            yield chunk
```
- ›Adds streaming tool support via autogen_core.tools.BaseStreamTool and autogen_core.tools.StreamWorkbench, exposing inner agent/team events through AgentTool and TeamTool when used with AssistantAgent.
- ›Adds tool_choice parameter to ChatCompletionClient create and create_stream methods for explicit tool selection control.
- ›Enables an inner tool-calling loop in AssistantAgent via the new max_tool_iterations constructor parameter, looping until the model stops generating tool calls or the limit is reached.
- ›Adds OpenTelemetry GenAI semantic-convention traces (create_agent, invoke_agent, execute_tool) for agents and tools; disable with AUTOGEN_DISABLE_RUNTIME_TRACING=true.
- ›Adds output_task_messages flag to run and run_stream to control whether input task messages are emitted in the event stream.
+5 moreshow less
- ›Adds Mem0 memory extension (autogen-ext) so agents can use Mem0 as a memory backend.
- ›Adds activation group support to GraphFlow for workflows with multiple cycles.
- ›Adds a message_id field to AgentChat messages.
- ›Adds ChromaDB embedding functions support to the ChromaDB extension.
- ›Adds support for Gemini 2.5 Flash stable model.
python-v0.6.1 Jun 5, 2025 · issue -365

AutoGen 0.6.1 adds function call and result listings to ToolCallSummaryMessage.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.1 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.6.1
```
- ›Adds list of function calls and their results to ToolCallSummaryMessage, making tool execution summaries more detailed and inspectable.
python-v0.6.0 Jun 5, 2025 · issue -365

AutoGen v0.6.0 adds concurrent GraphFlow agents, a new OpenAIAgent, callable edge conditions, Streamable HTTP MCP, and broader model support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.0 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.6.0
```
└──▷ USE IT
Run two translation agents concurrently after a writer agent using GraphFlow's fan-out pattern.
python
```
import asyncio

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import MaxMessageTermination
from autogen_agentchat.teams import DiGraphBuilder, GraphFlow
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main():
    model_client = OpenAIChatCompletionClient(model="gpt-4.1-nano")
    agent_a = AssistantAgent("A", model_client=model_client, system_message="You are a helpful assistant.")
    agent_b = AssistantAgent("B", model_client=model_client, system_message="Translate input to Chinese.")
    agent_c = AssistantAgent("C", model_client=model_client, system_message="Translate input to Japanese.")

    builder = DiGraphBuilder()
    builder.add_node(agent_a).add_node(agent_b).add_node(agent_c)
    builder.add_edge(agent_a, agent_b).add_edge(agent_a, agent_c)
    graph = builder.build()

    team = GraphFlow(
        participants=[agent_a, agent_b, agent_c],
        graph=graph,
        termination_condition=MaxMessageTermination(5),
    )

    async for event in team.run_stream(task="Write a short story about a cat."):
        print(event)

asyncio.run(main())
```
- ›Enables concurrent agent execution in GraphFlow via fan-out-fan-in patterns — select_speaker now returns List[str] | str.
- ›Adds callable (lambda/function) edge conditions for GraphFlow, replacing keyword substring matching.
- ›New OpenAIAgent backed by the OpenAI Responses API.
- ›Supports Streamable HTTP transport for MCP.
- ›Adds tool_call_summary_msg_format_fct parameter to AssistantAgent for custom tool-call summary formatting.
+10 moreshow less
- ›Supports multiple workbenches in AssistantAgent.
- ›Adds auto_delete option for temporary files in LocalCommandLineCodeExecutor.
- ›Adds language filtering for code blocks parsed from CodeExecutorAgent responses.
- ›Enables default usage statistics collection for streaming responses in OpenAIChatCompletionClient.
- ›Adds Llama API OAI-compatible endpoint support to OpenAIChatCompletionClient.
- ›Adds Qwen3 model support to OllamaChatCompletionClient.
- ›Allows implicit AWS credential resolution in AnthropicBedrockChatCompletionClient.
- ›Adds Claude Sonnet 4 and Claude Opus 4 to supported Anthropic models.
- ›Adds created_at field to BaseChatMessage and BaseAgentEvent.
- ›Uses structured output for the MagenticOne orchestrator.
└──▷ BREAKING ON UPGRADE
- !The return type of BaseGroupChatManager.select_speaker changed from str to List[str] | str — subclasses that override this method with a strict str return type annotation may need to be updated.
python-v0.5.7 May 14, 2025 · issue -366

AutoGen 0.5.7 unifies Azure AI Search methods, adds model context to SelectorGroupChat, and enriches OTEL tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.7 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.7
```
└──▷ USE IT
Run a semantic search over an Azure AI Search index using the new unified method instead of the removed create_keyword_search().
python
```
tool = AzureAISearchTool.create_full_text_search(
    name="my_search",
    endpoint="https://<your-service>.search.windows.net",
    index_name="<index>",
    api_key="<key>",
    query_type="semantic"
)
```
Limit the message history sent to the selector model in a long-running SelectorGroupChat to avoid exceeding context limits.
python
```
from autogen_agentchat.teams import SelectorGroupChat
from autogen_core.model_context import BufferedChatCompletionContext

team = SelectorGroupChat(
    participants=[agent1, agent2, agent3],
    model_client=model_client,
    model_context=BufferedChatCompletionContext(buffer_size=10)
)
```
- ›Adds unified AzureAISearchTool factory methods: create_full_text_search() (supporting "simple", "full", and "semantic" query types), create_vector_search(), and create_hybrid_search().
- ›Adds client-side embeddings support to AzureAISearchTool, falling back to service embeddings when client embeddings are not provided.
- ›Adds model_context parameter to SelectorGroupChat to customize which messages are sent to the model client when selecting the next speaker, enabling long-context speaker selection.
- ›Adds new metadata and message content fields to OTEL traces emitted by SingleThreadedAgentRuntime.
- ›Adds ability to register Agent instances directly with the Agent Runtime.
└──▷ BREAKING ON UPGRADE
- !The create_keyword_search() method on AzureAISearchTool is replaced by create_full_text_search() with "simple" query type; code using create_keyword_search() must be updated.
python-v0.5.6 May 2, 2025 · issue -366

AutoGen v0.5.6 adds GraphFlow for directed-graph agent workflows, Bing grounding citations, and Bedrock/Anthropic support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.6 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.6
```
└──▷ USE IT
Build a fan-out/fan-in pipeline where a writer feeds two parallel editors whose outputs are consolidated by a final reviewer — useful for parallel critique workflows.
python
```
from autogen_agentchat.teams import DiGraphBuilder, GraphFlow

builder = DiGraphBuilder()
builder.add_node(writer).add_node(editor1).add_node(editor2).add_node(final_reviewer)
builder.add_edge(writer, editor1)
builder.add_edge(writer, editor2)
builder.add_edge(editor1, final_reviewer)
builder.add_edge(editor2, final_reviewer)
graph = builder.build()

flow = GraphFlow(
    participants=builder.get_participants(),
    graph=graph,
)
await Console(flow.run_stream(task="Write a short biography of Steve Jobs."))
```
- ›Adds GraphFlow team class and DiGraphBuilder to AgentChat, enabling directed-graph agent workflows including fan-out, fan-in, and concurrent agent execution.
- ›Adds Bing grounding citation URL support to the Azure AI Agent integration.
- ›Adds Amazon Bedrock chat completion support for Anthropic models via a new provider in autogen_ext.
python-v0.5.5 Apr 25, 2025 · issue -367

AutoGen v0.5.5 adds Workbench abstraction for stateful MCP servers and a new FunctionalTermination condition for teams.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.5 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.5
```
└──▷ USE IT
Use a stateful MCP server (GitHub) with a shared session so all tools stay authenticated under one login context.
python
```
async with McpWorkbench(server_params) as mcp:
    agent = AssistantAgent(
        "github_assistant",
        model_client=model_client,
        workbench=mcp,
        reflect_on_tool_use=True,
        model_client_stream=True,
    )
    await Console(agent.run_stream(task="Is there a repository named Autogen"))
```
Drive a headless browser via Playwright MCP inside a multi-agent team, sharing browser state across all tool calls.
python
```
async with McpWorkbench(StdioServerParams(command="npx", args=["@playwright/mcp@latest", "--headless"])) as mcp:
    agent = AssistantAgent("web_browsing_assistant", model_client=model_client, workbench=mcp)
    team = RoundRobinGroupChat([agent], termination_condition=TextMessageTermination(source="web_browsing_assistant"))
    await Console(team.run_stream(task="Find out how many contributors for the microsoft/autogen repository"))
```
- ›Adds McpWorkbench — a new Workbench abstraction that lets agents share a single MCP server session across all tools, enabling stateful servers (e.g., login sessions, browser state) that tool adapters could not support.
- ›Enables AssistantAgent to accept a workbench= parameter, wiring it directly to a shared-session tool collection.
- ›Adds FunctionalTermination termination condition, letting teams define stop logic via an arbitrary function expression instead of only built-in conditions.
- ›Adds new sample demonstrating autogen-core + FastAPI for a handoff multi-agent pattern with streaming and a UI.
python-v0.5.4 Apr 22, 2025 · issue -367

AutoGen v0.5.4 adds AgentTool/TeamTool nesting, Azure AI Agent adapter, Docker Jupyter executor, and Canvas shared memory.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.4 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.4
```
└──▷ USE IT
Delegate sub-tasks to a specialist agent by wrapping it as a tool — useful when an orchestrator should call a writer, coder, or researcher on demand.
python
```
writer_tool = AgentTool(agent=writer)
assistant = AssistantAgent(
    name="assistant",
    model_client=model_client,
    tools=[writer_tool],
    system_message="You are a helpful assistant.",
)
```
Let a CodeExecutorAgent automatically retry and self-debug when generated code fails, reducing manual intervention in automated pipelines.
python
```
from autogen_agentchat.agents import CodeExecutorAgent

executor_agent = CodeExecutorAgent(
    name="coder",
    code_executor=executor,
    max_retries_on_error=3,
)
```
- ›Adds AgentTool and TeamTool to wrap agents and teams as callable tools for other agents, enabling nested agent hierarchies.
- ›Introduces AzureAIAgent adapter with support for file search, code interpreter, and Azure AI Agent service integration.
- ›Adds DockerJupyterCodeExecutor for sandboxed Jupyter code execution inside Docker containers.
- ›Introduces experimental CanvasMemory — a shared whiteboard memory letting multiple agents collaboratively read/write a common artifact.
- ›Adds autogen-contextplus community extension for advanced model context management with automatic summarization and truncation.
+4 moreshow less
- ›SelectorGroupChat now supports streaming-only models (e.g., QwQ) via new model_client_streaming=True parameter, and can emit inner selector reasoning with emit_team_events=True.
- ›CodeExecutorAgent gains max_retries_on_error parameter for automatic self-debugging retry loops on code execution failures.
- ›Adds multiple_system_messages field to ModelInfo to generalize continuous system-message merging across model providers.
- ›Docker code executor now supports exposing GPUs to the container.
python-v0.5.3 Apr 17, 2025 · issue -367

AutoGen 0.5.3 adds code generation to CodeExecutorAgent, serializable AssistantAgent, MCP shared sessions, and team event controls.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.3 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.3
```
└──▷ USE IT
Generate and immediately execute LLM-produced code in one agent turn — useful for data-analysis or automation tasks where you want a single agent to both write and run code.
python
```
from autogen_agentchat.agents import CodeExecutorAgent

# model_client enables code generation; executor runs the result
agent = CodeExecutorAgent(
    name="coder",
    code_executor=executor,
    model_client=model_client,
)
result = await agent.run(task="Write and run a Python script that prints the first 10 Fibonacci numbers.")
```
Suppress internal team-coordination events from the stream when you only want final agent messages, or enable them for debugging selector decisions.
python
```
from autogen_agentchat.teams import SelectorGroupChat

team = SelectorGroupChat(
    participants=[agent1, agent2],
    model_client=model_client,
    emit_team_events=True,   # set False to hide SelectorSpeakerEvent etc.
)
async for msg in team.run_stream(task="Analyze this dataset."):
    print(msg)
```
- ›Enables CodeExecutorAgent to generate and execute code in the same invocation via new code generation support.
- ›Adds autogen_core.utils module with JSON schema utilities, enabling AssistantAgent to be serialized when output_content_type is set.
- ›Introduces optional emit_team_events parameter on teams to control whether events like SelectorSpeakerEvent are emitted through run_stream.
- ›Allows mcp_server_tools factory to reuse a shared MCP session, enabling patterns like a persistent Playwright MCP server connection.
- ›Adds message type printing to the Console output.
python-v0.5.2 Apr 15, 2025 · issue -367

AutoGen v0.5.2 adds Gemini 2.5 Pro support and exposes more Task-Centric Memory parameters and TypedDict classes.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.2 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.2
```
- ›Adds Gemini 2.5 Pro Preview as a supported model.
- ›Exposes additional Task-Centric Memory (TCM) configuration parameters for finer control over memory behavior.
- ›Exposes TCM TypedDict classes so applications can directly reference and type-check Task-Centric Memory structures.
- ›Adds PowerShell path detection to the code executor for Windows environments.
python-v0.5.1 Apr 3, 2025 · issue -367

AutoGen v0.5.1 adds structured output, Azure AI Search tool, token-limited context, and richer model client capabilities.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.1 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.5.1
```
└──▷ USE IT
Have an AssistantAgent produce structured Pydantic output after a tool call — ideal for downstream programmatic consumption.
python
```
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.messages import TextMessage
from autogen_agentchat.ui import Console
from autogen_core import CancellationToken
from autogen_core.tools import FunctionTool
from autogen_ext.models.openai import OpenAIChatCompletionClient
from pydantic import BaseModel
from typing import Literal

class AgentResponse(BaseModel):
    thoughts: str
    response: Literal["happy", "sad", "neutral"]

def sentiment_analysis(text: str) -> str:
    return "happy" if "happy" in text else "sad" if "sad" in text else "neutral"

tool = FunctionTool(sentiment_analysis, description="Sentiment Analysis", strict=True)
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
agent = AssistantAgent(
    name="assistant",
    model_client=model_client,
    tools=[tool],
    system_message="Use the tool to analyze sentiment.",
    output_content_type=AgentResponse,
)
await Console(agent.on_messages_stream(
    [TextMessage(content="I am happy today!", source="user")], CancellationToken()
))
```
- ›Introduces StructuredMessage[T] generic message type, enabling custom application-defined message types in AgentChat.
- ›Adds output_content_type parameter to AssistantAgent so agents can emit structured Pydantic model responses via StructuredMessage.
- ›New AzureAISearchTool integration lets agents perform semantic/keyword search against Azure AI Search indexes.
- ›Adds candidate_func parameter to SelectorGroupChat for filtering the pool of agent candidates before selection.
- ›Adds async support for selector_func and candidate_func in SelectorGroupChat.
+7 moreshow less
- ›Adds cancellation support to the Docker code executor.
- ›Introduces TokenLimitedChatCompletionContext to cap token usage in long-running agent contexts.
- ›Adds thought field support to AzureAIChatCompletionClient and OllamaChatCompletionClient for reasoning/chain-of-thought tokens.
- ›Adds reasoning field to ModelClientStreamingChunkEvent to distinguish thought tokens from response tokens.
- ›Introduces modular Transformer Pipeline for model clients (e.g. Gemini/Anthropic content transforms).
- ›Extends model family resolution to support non-prefixed model names such as Mistral.
- ›Changes CodeExecutor default working directory to a temporary directory.
└──▷ BREAKING ON UPGRADE
- !Custom agents subclassing BaseChatAgent and custom TerminationCondition subclasses must update method signatures: replace AgentEvent with BaseAgentEvent and ChatMessage with BaseChatMessage in type hints.
- !The CodeExecutor default directory is now a temporary directory instead of the previous default, which may affect executors that relied on the old default path for output artifacts.
autogenstudio-v0.4.2 Mar 17, 2025 · issue -368

AutoGen Studio 0.4.2 adds component validation, LLM observability, token streaming, session comparison, Anthropic support, and experimental GitHub auth.
└──▷ GET THIS VERSION
```
$ git clone --branch autogenstudio-v0.4.2 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout autogenstudio-v0.4.2
```
└──▷ HOW TO FIND IT
Enable LLM call observability to inspect every LLMCallEvent during agent runs — useful for debugging prompt/response chains.
📍In AutoGen Studio, click the cog icon (Settings) in the lower-left corner and enable the LLM Call Observability option.
Stream tokens in real time for an agent to get immediate feedback during long LLM responses.
json
```
{
  "provider": "autogen_agentchat.agents.AssistantAgent",
  "config": {
    "name": "my_agent",
    "stream_model_client": true,
    "model_client": { ... }
  }
}
```
- ›Adds Component Validation API: all component schemas (teams, agents, models, tools, termination conditions) are automatically validated on save in the team builder, surfacing configuration errors early.
- ›Adds a Test button for model clients in the team builder UI to verify model configuration by running a live LLM query and displaying results.
- ›Adds LLM Call Observability: view all LLMCallEvents in AutoGen Studio via the Settings panel (cog icon, lower left).
- ›Adds token streaming in the AGS UI for agents where stream_model_client is set to true, displaying tokens as they are generated.
- ›Adds side-by-side Session Comparison in the playground: select multiple sessions and interact with them simultaneously to compare agent outputs.
+4 moreshow less
- ›Adds Anthropic model support in AutoGen Studio.
- ›Improves Gallery editing UI so teams, agents, models, tools, and termination conditions can be modified independently without requiring raw JSON review; Gallery is now persisted in a database rather than local storage.
- ›Adds experimental GitHub authentication support: pass an authentication configuration YAML file to enable user-scoped login and per-user session isolation.
- ›Adds experimental local Python code execution tool in AutoGen Studio.
└──▷ BREAKING ON UPGRADE
- !The Gallery is now persisted in a database rather than local storage, which may require migration of existing locally stored Gallery data.
python-v0.4.9 Mar 12, 2025 · issue -368

AutoGen v0.4.9 adds Anthropic & LlamaCpp model clients, task-centric memory, PowerShell execution, and pause/resume for agent teams.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.9 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.4.9
```
└──▷ USE IT
Run a local GGUF model or pull directly from Hugging Face for offline/private inference.
python
```
from autogen_ext.models.llama_cpp import LlamaCppChatCompletionClient
from autogen_core.models import UserMessage
import asyncio

async def main():
    client = LlamaCppChatCompletionClient(
        repo_id="unsloth/phi-4-GGUF", filename="phi-4-Q2_K_L.gguf",
        n_gpu_layers=-1, seed=1337, n_ctx=5000
    )
    result = await client.create([UserMessage(content="Summarize this report", source="user")])
    print(result)

asyncio.run(main())
```
Give an AssistantAgent persistent memory so it learns corrections and guidance across conversations.
python
```
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.experimental.task_centric_memory import MemoryController
from autogen_ext.experimental.task_centric_memory.utils import Teachability

client = OpenAIChatCompletionClient(model="gpt-4o-2024-08-06")
memory_controller = MemoryController(reset=False, client=client)
teachability = Teachability(memory_controller=memory_controller)

agent = AssistantAgent(
    name="teachable_agent",
    model_client=client,
    memory=[teachability],
)
```
- ›Adds AnthropicChatCompletionClient for native Anthropic model support, following the same interface as OpenAIChatCompletionClient.
- ›Adds LlamaCppChatCompletionClient for running local GGUF models or Hugging Face models via the llama-cpp SDK.
- ›Introduces experimental Task-Centric Memory (MemoryController, Teachability) enabling agents to learn from user teaching, self-improve, and persist knowledge beyond context-window limits.
- ›Adds LLMStreamStartEvent and LLMStreamEndEvent tracing events for LLM streaming.
- ›Adds ToolCallEvent logged from all built-in tools for richer tracing.
+6 moreshow less
- ›Supports tracing via context provider.
- ›Adds PowerShell support to LocalCommandLineCodeExecutor.
- ›Adds Pause and Resume capability for AgentChat Teams and Agents.
- ›Adds optional base path configuration to FileSurfer.
- ›Adds support for external agent runtime in AgentChat.
- ›Introduces Gitty, an experimental sample application that auto-replies to GitHub issues.
└──▷ BREAKING ON UPGRADE
- !Team state now uses the agent name as the key instead of the agent ID, and the team_id field is removed from serialized state; states saved with the old format may not be compatible with the new format.
python-v0.4.8 Mar 4, 2025 · issue -368

AutoGen v0.4.8 adds an Ollama chat client, ThoughtEvent streaming, new termination conditions, and a metadata field for AgentChat messages.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.8 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.4.8
```
└──▷ USE IT
Run inference against a local Ollama model instead of a cloud API — useful for air-gapped environments or cost control.
python
```
from autogen_ext.models.ollama import OllamaChatCompletionClient
from autogen_core.models import UserMessage

ollama_client = OllamaChatCompletionClient(model="llama3")
result = await ollama_client.create([UserMessage(content="Summarize this CVE.", source="user")])
print(result)
```
Get structured, schema-validated output from a local Ollama model — ideal for parsing threat intel or tool results into typed objects.
python
```
from autogen_ext.models.ollama import OllamaChatCompletionClient
from autogen_core.models import UserMessage
from pydantic import BaseModel

class ThreatActor(BaseModel):
    name: str
    country: str

ollama_client = OllamaChatCompletionClient(model="llama3", response_format=ThreatActor)
result = await ollama_client.create([UserMessage(content="Identify the threat actor in this report.", source="user")])
print(result)
```
- ›New OllamaChatCompletionClient enables local LLM inference via Ollama, with support for structured output and component-config loading.
- ›New thought field in CreateResult surfaces chain-of-thought text from tool calls; AssistantAgent emits it as a ThoughtEvent in the message stream (currently supported by OpenAIChatCompletionClient).
- ›New metadata field on AgentChat message base types lets applications attach custom key/value content to messages.
- ›New TextMessageTerminationCondition termination condition for halting single-agent teams based on text message content.
- ›New FunctionCallTermination termination condition for stopping a team when a specific function call is made.
+4 moreshow less
- ›Adds ChromaDBVectorMemory to the extensions package for vector-backed agent memory.
- ›Adds native Anthropic model client support via extensions.
- ›FileSurfer and CodeExecAgent are now declarative (support component config).
- ›Unhandled exceptions inside AgentChat agents (e.g., AssistantAgent) now propagate as fatal errors instead of silently stopping the team.
└──▷ BREAKING ON UPGRADE
- !The name field is now required in FunctionExecutionResult; existing code constructing FunctionExecutionResult without name will raise an error.
python-v0.4.7 Feb 17, 2025 · issue -369

AutoGen v0.4.7 adds strict tool mode, volume mounts for Docker executor, gRPC subscription APIs, and serializable CodeExecutors.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.7 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.4.7
```
└──▷ USE IT
Use strict mode on a FunctionTool to ensure compatibility with structured output mode when the model requires both simultaneously.
python
```
from autogen_core.tools import FunctionTool

def lookup_weather(city: str) -> str:
    return f"Sunny in {city}"

tool = FunctionTool(lookup_weather, name="lookup_weather", strict=True)
```
- ›Adds strict mode to BaseTool, ToolSchema, and FunctionTool, enabling tool calls to be used alongside structured output mode.
- ›Adds DockerCommandLineCodeExecutor support for additional volume mounts and exposed host ports.
- ›Adds remove and get subscription APIs to GrpcWorkerAgentRuntime for Python.
- ›Makes CodeExecutor components serializable, enabling persistence and transport of executor configuration.
└──▷ BREAKING ON UPGRADE
- !ModelInfo's required fields (vision, function_calling, json_output, family) are now enforced — model clients created without all required fields in model_info will fail.
python-v0.4.6 Feb 11, 2025 · issue -369

AutoGen 0.4.6 adds MCP and HTTP built-in tools, Gemini auto-config, and MagenticOne text-only model support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.6 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.4.6
```
└──▷ USE IT
Give an agent access to the full MCP ecosystem (e.g., web fetch) in a few lines — no custom tool wrappers needed.
python
```
from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools

fetch_mcp_server = StdioServerParams(command="uvx", args=["mcp-server-fetch"])
tools = await mcp_server_tools(fetch_mcp_server)

agent = AssistantAgent(name="fetcher", model_client=model_client, tools=tools, reflect_on_tool_use=True)
```
Expose any REST API to an agent declaratively — no wrapper function, just a schema and endpoint config.
python
```
from autogen_ext.tools.http import HttpTool

base64_tool = HttpTool(
    name="base64_decode",
    description="base64 decode a value",
    scheme="https",
    host="httpbin.org",
    port=443,
    path="/base64/{value}",
    method="GET",
    json_schema={"type": "object", "properties": {"value": {"type": "string"}}, "required": ["value"]},
)
assistant = AssistantAgent("base64_assistant", model_client=model, tools=[base64_tool])
```
Use Gemini models without boilerplate — no model_info or base_url required.
python
```
from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(
    model="gemini-1.5-flash-8b",
    # api_key="GEMINI_API_KEY",
)
```
- ›Adds mcp_server_tools and StdioServerParams in autogen_ext.tools.mcp to connect agents to any Model Context Protocol (MCP) server (file system, Git, web fetch, etc.).
- ›Adds HttpTool in autogen_ext.tools.http for agents to call remote HTTP/REST API endpoints with a declarative JSON schema.
- ›Enables Gemini models in OpenAIChatCompletionClient without requiring manual model_info or base_url arguments.
- ›Adds text-only model support to MagenticOne (M1), allowing it to run without screenshot/vision capability.
- ›Allows the m1 CLI to read configuration from a YAML file.
+6 moreshow less
- ›Improves SelectorGroupChat compatibility with smaller models (e.g., LLaMA 13B) and hosted models that do not support the name field in Chat Completion messages.
- ›Adds the Claude model family to ModelFamily.
- ›Adds the o3-mini model to the o3 family in ModelFamily.
- ›Adds a tool-failure indicator field to FunctionExecutionResult.
- ›Adds a Memory component base to autogen-ext.
- ›Introduces a new FastAPI sample demonstrating real-time agent chat with WebSocket human-in-the-loop integration.

python-v0.4.5 Feb 1, 2025 · issue -369

AutoGen 0.4.5 adds token streaming for agents/teams, R1 reasoning output, partial-function tools, and a new CodeExecutorAgent sources parameter.

└──▷ GET THIS VERSION

$ git clone --branch python-v0.4.5 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout python-v0.4.5

└──▷ USE IT

Inspect chain-of-thought reasoning from a DeepSeek-R1 model to audit how conclusions are reached.

python

from autogen_core.models import UserMessage, ModelFamily
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="deepseek-r1:1.5b",
    api_key="placeholder",
    base_url="http://localhost:11434/v1",
    model_info={"function_calling": False, "json_output": False, "vision": False, "family": ModelFamily.R1},
)
result = await client.create(messages=[UserMessage(content="Is this log line indicative of a brute-force attack?", source="user")])
print("Reasoning:", result.thought)
print("Answer:", result.content)

Bind fixed parameters (e.g., a tenant or region) upfront so an agent only needs to supply the remaining arguments.

python

from functools import partial
from autogen_core.tools import FunctionTool

def query_logs(environment: str, severity: str, keyword: str) -> str:
    return f"Querying {environment} logs for {severity} events matching '{keyword}'"

prod_logs = partial(query_logs, "production", "ERROR")
tool = FunctionTool(prod_logs, description="Query production ERROR logs by keyword.")
print(tool.schema)  # schema only exposes 'keyword'

›Adds model_client_stream=True on AssistantAgent and the new ModelClientStreamingChunkEvent message type to stream model tokens in real time through run_stream or Console.
›Supports R1-style reasoning output via a new CreateResult.thought field, populated when using models in the ModelFamily.R1 family (e.g., DeepSeek-R1).
›Enables FunctionTool to wrap functools.partial functions, automatically excluding pre-bound parameters from the generated tool schema.
›Adds an optional sources parameter to CodeExecutorAgent to control which message sources it extracts code from.
›Adds o3 to the built-in model info registry.

v0.4.4 Jan 29, 2025 · issue -370

AutoGen v0.4.4 adds serializable agent/team configs, Azure AI model client, rich CLI output, and zero-config in-memory LLM caching.

└──▷ GET THIS VERSION

$ git clone --branch v0.4.4 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.4.4

└──▷ USE IT

Persist a multi-agent team across sessions by serializing its config and state to disk, then reloading both later.

python

config = group_chat.dump_component()
with open("team_config.json", "w") as f:
    f.write(config.model_dump_json(indent=4))
state = await group_chat.save_state()
with open("team_state.json", "w") as f:
    f.write(json.dumps(state, indent=4))

# Later, restore the team:
with open("team_config.json", "r") as f:
    config = json.load(f)
group_chat = Team.load_component(config)
with open("team_state.json", "r") as f:
    state = json.load(f)
await group_chat.load_state(state)

Use GitHub-hosted Phi-4 via the new Azure AI client without switching to the OpenAI client.

python

from autogen_ext.models.azure import AzureAIChatCompletionClient
from azure.core.credentials import AzureKeyCredential

client = AzureAIChatCompletionClient(
    model="Phi-4",
    endpoint="https://models.inference.ai.azure.com",
    credential=AzureKeyCredential(os.environ["GITHUB_TOKEN"]),
    model_info={"json_output": False, "function_calling": False, "vision": False, "family": "unknown"},
)
result = await client.create([UserMessage(content="Summarize this CVE.", source="user")])

Wrap any model client with zero-config in-memory caching to avoid redundant LLM calls during repeated queries.

python

from autogen_ext.models.cache import ChatCompletionCache
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(model="gpt-4o")
cached_client = ChatCompletionCache(client)
result = await cached_client.create([UserMessage(content="What is the capital of France?", source="user")])
print(result.content, result.cached)  # False on first call, True on subsequent identical calls

›Adds dump_component() and load_component() to serialize/deserialize agent and team configurations to/from JSON, enabling persistent sessions across server-client interactions.
›Introduces AzureAIChatCompletionClient in autogen_ext.models.azure for Azure- and GitHub-hosted models including Phi-4, Mistral, and Cohere.
›Adds --rich flag to the m1 CLI for pretty-printed, colorized console output via the Rich library.
›Adds a default in-memory store to ChatCompletionCache, enabling model call caching without configuring an external cache service.
›Adds description field support in dump_component() output for richer component metadata.

v0.4.3 Jan 22, 2025 · issue -370

AutoGen v0.4.3 adds model response caching, GraphRAG tools, Semantic Kernel adapters, Jupyter execution, and agent memory.

└──▷ GET THIS VERSION

$ git clone --branch v0.4.3 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.4.3

└──▷ USE IT

Cache OpenAI completions to disk so repeated identical prompts are served instantly without additional API calls.

python

from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.models.cache import ChatCompletionCache, CHAT_CACHE_VALUE_TYPE
from autogen_ext.cache_store.diskcache import DiskCacheStore
from autogen_core.models import UserMessage
from diskcache import Cache
import asyncio

async def main():
    openai_client = OpenAIChatCompletionClient(model="gpt-4o")
    cache_store = DiskCacheStore[CHAT_CACHE_VALUE_TYPE](Cache("/tmp/autogen-cache"))
    cache_client = ChatCompletionCache(openai_client, cache_store)

    response = await cache_client.create([UserMessage(content="Summarise zero-trust networking.", source="user")])
    print(response)  # live response
    response = await cache_client.create([UserMessage(content="Summarise zero-trust networking.", source="user")])
    print(response)  # served from disk cache

asyncio.run(main())

Give an agent global GraphRAG search capability to answer broad, dataset-wide questions from an indexed knowledge graph.

python

from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.graphrag import GlobalSearchTool
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
import asyncio

async def main():
    global_tool = GlobalSearchTool.from_settings(settings_path="./settings.yaml")
    agent = AssistantAgent(
        name="search_assistant",
        tools=[global_tool],
        model_client=OpenAIChatCompletionClient(model="gpt-4o-mini"),
        system_message="Use global_search for broad questions about the dataset.",
    )
    await Console(agent.run_stream(task="What are the main themes across all community reports?"))

asyncio.run(main())

›Adds ChatCompletionCache to wrap any ChatCompletionClient and transparently cache model completions, with DiskCacheStore and RedisStore backends via a new CacheStore interface.
›Adds LocalSearchTool and GlobalSearchTool for GraphRAG integration, enabling agents to call local and global graph-based retrieval as first-class tools.
›Adds SKChatCompletionAdapter to adapt any Semantic Kernel AI Connector into an AutoGen ChatCompletionClient.
›Adds KernelFunctionFromTool adapter to expose AutoGen tools as Kernel functions inside a Semantic Kernel workflow.
›Adds JupyterCodeExecutor for local Jupyter-based code execution, restoring functionality from the 0.2 lineage.

+3 moreshow less

›Introduces a core Memory interface for agent memory and RAG; AssistantAgent now accepts a memory parameter to enrich context from a memory store.
›Expands declarative config support to termination conditions and base chat agents, moving toward full team-of-agents configuration from a single file.
›Adds sources field to TextMentionTermination for filtering by message source.

v0.4.1 Jan 13, 2025 · issue -370

AutoGen v0.4.1 enables subclassing BaseComponent for custom serializable component configs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.1 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.4.1
```
- ›Supports subclassing BaseComponent to create custom component configs with serialization support.
└──▷ BREAKING ON UPGRADE
- !Console output usage statistics are now disabled by default.
v0.4.0 Jan 10, 2025 · issue -370

AutoGen v0.4.0 stable: agent activate/deactivate, o1-2024-12-17 model support, and new m1 CLI package.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.0 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.4.0
```
- ›Adds m1 CLI package for interacting with AutoGen agents from the command line.
- ›Supports activating and deactivating individual agents at runtime.
- ›Adds support for the o1-2024-12-17 model in autogen-ext[openai].
└──▷ BREAKING ON UPGRADE
- !The Azure auth provider has been moved to a separate module; existing imports will break.
- !The intervention handler signature now requires a message_context argument; existing intervention handler implementations will break.
- !Deprecated items removed for the v0.4.0 release; any code relying on previously deprecated APIs will break.
v0.2.40 Dec 15, 2024 · issue -371

AutoGen v0.2.40 adds a warning when no eligible speaker is found in group chats.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.40 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.40
```
- ›Adds a warning message when no eligible speaker is available in a group chat (NoEligibleSpeaker), surfacing silent failures that previously went unnoticed.
v0.2.37 Oct 23, 2024 · issue -373

AutoGen v0.2.37 adds Kubernetes code execution, Gemini function calling, and AutoBuild function calling support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.37 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.37
```
- ›Adds a Kubernetes code executor, enabling sandboxed code execution inside K8s pods.
- ›Adds function calling support for Gemini models (Part 2), expanding tool-use capabilities to Google's Gemini backend.
- ›Enables function calling in AutoBuild, allowing automatically constructed agent teams to invoke tools.
- ›Adds LangChain integration example, demonstrating interoperability between LangChain and AutoGen agents.
- ›Adds Couchbase as a supported vector database backend with an example notebook.
+1 moreshow less
- ›Adds Zep memory integration with documentation and notebook.
└──▷ BREAKING ON UPGRADE
- !The Text Cache default is changed to None (previously a non-None default); setups relying on the old default cache behavior will no longer cache by default after upgrading.
v0.2.36 Oct 2, 2024 · issue -373

AutoGen v0.2.36 adds Mem0 long-term memory, Amazon Bedrock, Cerebras, Ollama (with tool calling), Couchbase VectorDB, and Portkey integrations.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.36 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.36
```
└──▷ USE IT
Apply a MessageTransform to the GroupChat speaker-selection nested chat to control context sent to the selector LLM.
python
```
from autogen.agentchat.contrib.capabilities.transform_messages import TransformMessages
from autogen.agentchat.contrib.capabilities.transforms import MessageHistoryLimiter
from autogen import GroupChat, GroupChatManager

transforms = TransformMessages(transforms=[MessageHistoryLimiter(max_messages=10)])

groupchat = GroupChat(
    agents=[agent1, agent2, agent3],
    messages=[],
    speaker_selection_method="auto",
    select_speaker_transform_messages=transforms,
)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)
```
- ›Adds Mem0 integration for long-term memory support in AI agents.
- ›Adds Amazon Bedrock client for model access via AWS.
- ›Adds Cerebras integration as a new LLM provider.
- ›Adds Ollama client with tool-calling support.
- ›Adds Couchbase VectorDB support for retrieval-augmented generation workflows.
+11 moreshow less
- ›Adds Portkey integration for LLM observability and routing.
- ›Enables MessageTransforms on GroupChat's Select Speaker nested chat when using speaker_selection_method='auto'.
- ›Adds a MessageTransform that injects an agent's name into message content.
- ›Adds GraphRAG interfaces for graph-based retrieval-augmented generation.
- ›Adds Human Input Mode support in AutoGen Studio.
- ›Updates WebSurfer with Selenium, Playwright, and support for many additional file types.
- ›Adds async user hook support.
- ›Adds kwargs passthrough to the Docker container running the Jupyter Server.
- ›Adds session cookie forwarding from HTTP session to the WebSocket used by JupyterCodeExecutor.
- ›Adds API call throttling capability.
- ›AutoGen is now published on PyPI as autogen-agentchat starting with this version.
v0.2.35 Aug 20, 2024 · issue -375

AutoGen v0.2.35 adds Mistral v1.0.1 support, .NET Anthropic cache control, and decouples RetrieveChat from RetrieveAssistantAgent.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.35 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.35
```
- ›Updates Mistral client class to support the new Mistral v1.0.1 package.
- ›Adds cache control support to the .NET Anthropic client.
- ›Removes dependency on RetrieveAssistantAgent for RetrieveChat, enabling more flexible retrieval-augmented chat setups.
└──▷ BREAKING ON UPGRADE
- !TransformChatHistory and CompressibleAgent are removed; any code referencing these classes will break on upgrade.
v0.2.34 Aug 12, 2024 · issue -375

AutoGen v0.2.34 adds async nested chats, a global silent param, Azure AI Inference integration, and last_speaker tracking in GroupChat.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.34 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.34
```
└──▷ USE IT
Silence all agent output globally when running an automated pipeline where console chatter is unwanted.
python
```
agent = ConversableAgent(
    name="assistant",
    silent=True,
    llm_config={"config_list": config_list},
)
```
Run nested chats asynchronously to avoid blocking the event loop in async applications.
python
```
result = await initiator.a_initiate_chats(chat_queue)
```
- ›Adds silent global parameter to ConversableAgent to suppress output across all agents from a single setting.
- ›Supports async nested chats, enabling non-blocking multi-agent conversation flows.
- ›Adds last_speaker attribute to GroupChatManager for tracking which agent spoke last in a group chat.
- ›Introduces AutoGen.AzureAIInference package (.NET) for Azure AI Inference model support.
- ›Adds DotnetInteractiveKernelBuilder to the AutoGen.DotnetInteractive package (.NET).
+4 moreshow less
- ›Adds DotnetInteractiveStdioConnector to AutoGen.DotnetInteractive (.NET) for stdio-based kernel connectivity.
- ›Adds a runtime factory ([CAP]) for more flexible agent runtime instantiation.
- ›Adds support for gpt-4o-2024-08-06 model in the model catalogue.
- ›Enhances tool calling support for Cohere models.
v0.2.33 Jul 30, 2024 · issue -376

AutoGen v0.2.33 adds Qdrant and MongoDB Atlas vector stores, Gemini via VertexAI, and Anthropic Bedrock support for RAG and LLM backends.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.33 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.33
```
- ›Adds Qdrant as a supported VectorDB backend for RetrieveChat RAG pipelines.
- ›Adds MongoDB Atlas vector search as a VectorDB backend for AutoGen RAG.
- ›Adds Gemini support via Google VertexAI as an LLM provider.
- ›Adds Anthropic Bedrock as a supported LLM backend.
- ›Adds gpt-4o-mini to the built-in model list.
+1 moreshow less
- ›Updates human-input-mode prompt to include the responding agent's name, improving multi-agent conversation clarity.
v0.2.32 Jul 4, 2024 · issue -376

AutoGen v0.2.32 adds Groq and Cohere client support, expanding non-OpenAI model integrations.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.32 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.32
```
- ›Adds Groq client support, enabling AutoGen agents to use Groq-hosted models as a drop-in LLM backend.
- ›Adds Cohere client support, enabling AutoGen agents to use Cohere models as a drop-in LLM backend.
- ›Adds tool/function-call support for AnthropicClient and AnthropicAgent in the .NET SDK.
v0.2.30 Jun 21, 2024 · issue -377

AutoGen v0.2.30 adds native Anthropic, Mistral, and Together.AI LLM clients with a uniform multi-provider interface.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.30 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.30
```
- ›Adds AnthropicClient with support for claude-3-5-sonnet-20240620, enabling Anthropic models to participate alongside OpenAI GPT models in group chats.
- ›Adds MistralClient for native Mistral AI model support without OpenAI compatibility shims.
- ›Adds Together.AI Client for access to the Together.AI model catalog.
- ›Adds a uniform interface for calling different LLMs, normalizing the integration surface across OpenAI and non-OpenAI providers.
- ›Adds client class utilities and a function to indicate whether to hide tools per client (client_utils), supporting provider-specific tool-visibility control.
+1 moreshow less
- ›Adds async a_initiate_chats update enabling asynchronous multi-chat orchestration.
v0.2.29 Jun 14, 2024 · issue -377

AutoGen v0.2.29 adds LlamaIndex agent integration, AgentOps logging, Gemini improvements, and AAD auth for Azure clients.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.29 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.29
```
- ›Adds LlamaIndex agent integration, enabling LlamaIndex agents to participate in AutoGen group chats.
- ›Adds AgentOps runtime logging integration for observability across AutoGen agent sessions.
- ›Adds support for passing custom pricing in config_list, allowing cost tracking for non-standard or self-hosted models.
- ›Adds tag-based model filtering in config_list as an alternative to filtering by model name.
- ›Adds AAD (Azure Active Directory) auth support to the Azure client.
+4 moreshow less
- ›Adds Google Gemini support to AutoGen.Net (v0.0.15), including Gemini samples on the AutoGen.Net website.
- ›Adds image input support for Anthropic models in AutoGen.Net.
- ›Adds AOT (Ahead-of-Time) compatibility check for AutoGen.Net Core.
- ›Allows a function to remove termination strings in group chat, giving finer control over conversation endings.
v0.2.28 May 31, 2024 · issue -378

AutoGen v0.2.28 adds resumable group chat, LLMLingua text compression, silent mode, and Anthropic/Ollama/.NET integrations.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.28 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.28
```
└──▷ USE IT
Bind a host directory into a Docker code executor so generated files persist on the host after execution.
python
```
from autogen.coding import DockerCommandLineExecutor

executor = DockerCommandLineExecutor(bind_dir="/host/workspace")
```
- ›Adds bind_dir argument to DockerCommandLineExecutor to bind a host directory into the container at execution time.
- ›Adds ability to use a separate Python environment in the local code executor (LocalCommandLineCodeExecutor).
- ›Adds silent option to nested chats and group chat to suppress message output.
- ›Adds ability to ignore the select-speaker prompt for GroupChat, giving finer control over speaker-selection behaviour.
- ›Adds support for ignoring specific messages when applying TransformMessages transformations.
+18 moreshow less
- ›Adds FileLogger as a custom runtime logger, enabling structured event logging to a file.
- ›Adds a warning when a duplicate function is registered with an agent.
- ›Supports resuming a GroupChat from a previous state — enabling interruptible, long-running multi-agent conversations.
- ›Adds role parameter to reflection-with-LLM, allowing custom role assignment during reflective reasoning.
- ›Adds GPT-4o token-count support to token-count utilities.
- ›Enables function calling with GPTAssistantAgent, including full guide and notebook example.
- ›Adds experimental AgentEval integration for agent evaluation workflows.
- ›Adds PGVector support for custom connection objects in the RAG retrieval backend.
- ›Introduces AnthropicClient and AnthropicClientAgent for Anthropic model support (Python).
- ›Adds Gemini safety settings and generation config parameters to the Gemini client.
- ›Adds Ollama integration for the .NET AutoGen library (AutoGen.Ollama).
- ›Introduces ChatCompletionAgent to the AutoGen.SemanticKernel .NET package.
- ›Adds KernelPluginMiddleware to AutoGen.SemanticKernel .NET package.
- ›Introduces ToolCallAggregateMessage type in the .NET library.
- ›Rewrites AutoGen Studio database layer to use SQLModel ORM.
- ›Improves AutoGen Agents support in the CAP (Connected Agents Platform) integration.
- ›Adds support for raw-data in ImageMessage in the .NET library.
- ›Adds third-party OpenAI API endpoint connection support with example in the .NET library.
v0.2.27 Apr 30, 2024 · issue -379

AutoGen v0.2.27 adds .NET support, OpenAI Assistant v2, message history init, event logging, HTML/CSS/JS code execution, and Azure Cosmos DB caching.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.27 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.27
```
- ›Adds message history initialization to ConversableAgent, allowing agents to be seeded with prior conversation context.
- ›Adds an event logging API with expanded tracing support via the new event logging feature.
- ›Adds HTML, CSS, and JavaScript language support to LocalCommandLineCodeExecutor, enabling front-end code execution.
- ›Adds a new caching backend using Azure Cosmos DB.
- ›Supports the OpenAI Assistant v2 API.
+4 moreshow less
- ›Introduces AutoGen.NET (AutoGen for .NET), a new language runtime for building agents in C#.
- ›Re-queries the speaker name when multiple speaker names are returned during Group Chat speaker selection, improving robustness.
- ›Makes the port number optional in JupyterConnectionInfo().
- ›Adds min_tokens support to the token limiter.
v0.2.26 Apr 19, 2024 · issue -379

AutoGen v0.2.26 adds PGVector support for RAG, selective carryover in initiate_chats, and sk-proj- OpenAI API key format.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.26 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.26
```
- ›Adds vector_db as a settable parameter in retrieval-augmented chat contrib, enabling customizable vector database backends including PGVector.
- ›Enhances initiate_chats to support selective carryover of context between chats.
- ›Supports OpenAI sk-proj- API key format.
- ›New integration example with promptflow in samples/apps/promptflow-autogen.
v0.2.25 Apr 17, 2024 · issue -379

AutoGen v0.2.25 adds Gemini model support and custom Bing Search base URL for the browser agent.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.25 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.25
```
- ›Adds support for a custom base URL for Bing Search in the browser agent, enabling use of proxy or regional endpoints.
- ›Adds Google Gemini as a supported model provider for AutoGen agents.
v0.2.24 Apr 15, 2024 · issue -379

AutoGen v0.2.24 adds Anthropic Claude function calling, a customizable vectordb module, and CosmosDB support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.24 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.24
```
└──▷ TRY IT
Install AutoGen with CosmosDB support to use it as a vector store for RAG.
```
$ pip install pyautogen[cosmosdb]
```
- ›Adds extra_require for cosmosdb in setup.py, enabling optional CosmosDB installation as a vector store backend.
- ›Adds a vectordb module with a customizable vector database interface for RAG pipelines.
- ›Adds function call support for Anthropic Claude via the latest Anthropic API.
- ›Adds llm_config support in AgentOptimizer, allowing LLM configuration to be passed directly to the optimizer.
- ›Adds 'py' as a recognized language tag in ConversableAgent code execution, enabling Python code blocks to be detected and run.
+2 moreshow less
- ›Adds source attribution to the default RAG prompt answer, surfacing where retrieved content originated.
- ›Standardizes printing of MessageTransforms for more consistent and readable usage and cost output.
v0.2.22 Apr 6, 2024 · issue -379

AutoGen v0.2.22 adds TransformMessages capability, Anthropic Claude support, GroupChat speaker customization, and an in-memory cache class.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.22 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.22
```
└──▷ USE IT
Cap the number of tokens passed to the retriever in RetrieveUserProxyAgent to control cost and latency.
python
```
retrieve_user_proxy = RetrieveUserProxyAgent(
    name="retrieve_proxy",
    retrieve_config={
        "docs_path": "./docs",
        "context_max_tokens": 2000,
    }
)
```
- ›Adds TransformMessages capability as a generalized replacement for previous long-context handling — prior long-context capabilities are now deprecated.
- ›Adds support for Anthropic Claude models, including system message support in Claude-based workflows.
- ›Adds an in-memory cache class (Add in memory cache class) for LLM response caching without disk I/O.
- ›Adds context_max_tokens support in RetrieveUserProxyAgent via retrieve_config, giving fine-grained control over retrieval context size.
- ›Adds ability to specify the role field for select-speaker messages in GroupChat, enabling Mistral and other non-OpenAI models to function correctly in group chat speaker selection.
+5 moreshow less
- ›Adds customization of the speaker-select message and prompt in GroupChat.
- ›Expands speaker name matching during speaker selection in GroupChat to handle a broader range of model response formats.
- ›Adds string-based UDF (user-defined function) support.
- ›Adds an HTML parser for RAG pipelines.
- ›Adds AutoDefense research integration: a multi-agent defense mechanism against LLM jailbreak attacks using AutoGen.
v0.2.21 Mar 28, 2024 · issue -380

AutoGen v0.2.21 adds AgentOptimizer, Vision Capability, IOStream/WebSocket support, Mistral native tool calls, and user-defined functions in the local CLI executor.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.21 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.21
```
- ›Adds AgentOptimizer, a research-backed agent that iteratively improves tool sets used by agents during multi-turn conversations.
- ›Adds user-defined functions support to the local CLI executor, bringing 'skills'-style extensibility (previously only in AutoGen Studio) to the code execution API.
- ›Adds VisionCapability for ConversableAgent, enabling agents to process and reason about images via GPT-4V-style multimodal inputs.
- ›Introduces the IOStream protocol with WebSocket support, allowing agent conversations to stream I/O over WebSocket connections.
- ›Adds native tool call support for the Mistral AI API custom model, enabling function/tool calling without OpenAI compatibility shims.
+2 moreshow less
- ›Adds WebArena benchmarking tool under samples/tools/webarena for running and evaluating agents against the WebArena benchmark.
- ›Adds ability to retrieve the list of actors from the directory service via the CAP (actor platform) layer.
v0.2.20 Mar 21, 2024 · issue -380

AutoGen v0.2.20 adds image generation, Azure AI Search support, streaming replies, and a composable actor platform.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.20 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.20
```
└──▷ USE IT
Enable Azure AI Search in AutoGen Studio by adding extra_body to your LLM config.
json
```
{
  "model": "gpt-4",
  "api_type": "azure",
  "api_key": "<your-key>",
  "base_url": "<your-azure-endpoint>",
  "extra_body": {
    "dataSources": [
      {
        "type": "AzureCognitiveSearch",
        "parameters": {
          "endpoint": "<search-endpoint>",
          "key": "<search-key>",
          "indexName": "<index-name>"
        }
      }
    ]
  }
}
```
- ›Adds extra_body field to LLMConfig dataclass to enable Azure AI Search support in AutoGen Studio.
- ›New ImageGenerationCapability contrib feature (2.0) lets agents generate images as part of conversations.
- ›New Composable Actor Platform (CAP) sample app enables distributed, actor-based AutoGen agent deployments.
- ›AutoGen Studio gains upload/download of Skills and Workflows, streaming agent replies, and agent message summarization.
- ›Nested chat now supports different senders, enabling more flexible multi-agent conversation topologies.
+1 moreshow less
- ›Separates OpenAI Assistants API config items from the general llm_config in GPTAssistantAgent.
v0.2.18 Mar 12, 2024 · issue -380

AutoGen v0.2.18 adds callable messages, a fine-tuning tool for conversable agents, and a Docker-based command-line code executor.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.18 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.18
```
- ›Adds LocalCommandLineCodeExecutor support for accepting a path object for work_dir, in addition to strings.
- ›Implements a Docker-based CommandLineCodeExecutor for sandboxed, containerized code execution.
- ›Supports callable messages, allowing user-defined message functions to control what agents send to one another.
- ›Adds a fine-tuning tool (samples/tools/finetuning) for training custom models on conversable agents.
└──▷ BREAKING ON UPGRADE
- !CompressibleAgent now requires a model field in llm_config; configurations omitting it will break.
v0.2.17 Mar 7, 2024 · issue -380

AutoGen v0.2.17 adds customizable speaker selection for group chats and tightens nested chat registration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.17 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.17
```
- ›Allows users to pass a customized speaker selection method into group chat, enabling fully programmable agent turn-ordering beyond the built-in strategies.
- ›Removes the default trigger value for register_nested_chats, requiring callers to supply an explicit trigger and making nested chat configuration unambiguous.
- ›Raises errors when incompatible arguments are used together with a code executor, surfacing misconfiguration at startup instead of silently misbehaving.
- ›Adjusts message processing order to ensure proper combination of agent capabilities across multi-agent pipelines.
└──▷ BREAKING ON UPGRADE
- !The class LocalCommandlineCodeExecutor has been renamed to LocalCommandLineCodeExecutor; any code importing or referencing the old name will break.
- !register_nested_chats no longer has a default trigger value; callers that relied on the default must now pass an explicit trigger argument or the call will fail.
v0.2.16 Mar 1, 2024 · issue -380

AutoGen v0.2.16 adds register_nested_chats, a Docker-based Jupyter executor, and expanded hook and function-removal APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.16 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.16
```
- ›Adds register_nested_chats method to simplify composing nested chats, letting agents use other multi-agent conversations as inner monologue before replying.
- ›Adds support for removing function calls in ConversableAgent.
- ›Hook methods updated to accept a sender argument, enabling per-sender logic in hook callbacks.
- ›Introduces a Docker-based Jupyter executor for sandboxed, container-isolated code execution.
- ›FSM-based group chat with user-specified agent transitions now documented via an official blog post.
v0.2.15 Feb 25, 2024 · issue -381

AutoGen v0.2.15 adds async multi-chat, group chat introductions, per-chat max-turn limits, and a message-processing hook.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.15 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.15
```
└──▷ USE IT
Cap a conversation at a fixed number of turns to prevent runaway agent loops in CI or cost-sensitive pipelines.
python
```
user_proxy.initiate_chat(assistant, message="Summarise this doc", max_turns=5)
```
- ›Adds max_turns parameter to initiate_chat and initiate_chats to limit the maximum number of turns in a conversation.
- ›Adds async version of multiple sequential chats, enabling non-blocking orchestration of dependent multi-agent pipelines.
- ›Adds group chat introductions: participants can now send introductions at the start of a group chat so agents know each other's roles.
- ›Adds message processing hook to ConversableAgent allowing messages to be transformed before sending — enabling custom frontend display and other pre-send logic.
- ›Adds jupyter-kernel-gateway support for the IPython code executor.
+3 moreshow less
- ›Allows None for the sender field in ConversableAgent.generate_reply, broadening reply generation to sender-agnostic contexts.
- ›Releases AutoGenBench v0.0.2.
- ›Adds azure_deployment parameter handling in GPTAssistantAgent to maintain compatibility with OpenAIWrapper and Azure OpenAI.
v0.2.14 Feb 16, 2024 · issue -381

AutoGen v0.2.14 adds callable summary methods, runtime logging, Azure assistant API support, and GroupChat agent lookup.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.14 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.14
```
└──▷ USE IT
Pass a custom callable as summary_method in initiate_chats to control how each chat's result is summarised before the next one starts.
python
```
import autogen

def my_summary(recipient, messages, sender, config):
    return messages[-1]['content'][:200]

autogen.initiate_chats([
    {"sender": agent_a, "recipient": agent_b, "message": "Start task", "summary_method": my_summary},
    {"sender": agent_b, "recipient": agent_c, "message": "Continue",   "summary_method": my_summary},
])
```
- ›Adds autogen.initiate_chats top-level function to start sequential chats initiated by different agents.
- ›Adds callable summary_method support to initiate_chats, allowing custom summarization logic to be passed as a Python callable.
- ›Adds nested_agents property and agent_by_name lookup to GroupChat, enabling retrieval of nested agents and name-based agent resolution.
- ›Adds runtime logging capability to ConversableAgent-based conversations for recording and auditing agent interactions.
- ›Adds Azure assistant API support to GPTAssistantAgent.
+2 moreshow less
- ›Adds is_termination_msg validation to GPTAssistantAgent, respecting termination conditions and human input mode.
- ›Adds OpenAI API key format validation and llm_config validation on ConversableAgent construction.
v0.2.13 Feb 11, 2024 · issue -381

AutoGen v0.2.13 adds a long-context handling agent capability and a new extensible code execution interface with stateful executors.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.13 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.13
```
- ›Adds a new extensible agent capability for long context handling, enabling agents to operate over inputs that exceed standard context windows.
- ›Introduces a new extensible code execution interface with support for stateful executors, allowing code state to persist across execution steps.
v0.2.12 Feb 8, 2024 · issue -381

AutoGen v0.2.12 adds SocietyOfMind function-calling support, exposes filter_config, and introduces multiple sequential chats and a Discord bot.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.12 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.12
```
└──▷ USE IT
Filter a list of LLM configs by model or other criteria before passing them to an agent.
python
```
from autogen import filter_config

config_list = [
    {"model": "gpt-4", "api_key": "..."},
    {"model": "gpt-3.5-turbo", "api_key": "..."}
]
filtered = filter_config(config_list, {"model": ["gpt-4"]})
```
- ›Exposes filter_config function as a public API for filtering LLM config lists.
- ›Adds max_tokens field to AutoGen Studio's LLMConfig, enabling token-limit control in Studio-configured models.
- ›Enables SocietyOfMind agents to participate in function calling and tool use workflows.
- ›Introduces multiple sequential chats interface, allowing a sequence of chats to be programmed with results carried forward between them.
- ›Introduces AutoAnny, a Discord bot built with AutoGen demonstrating real-time agent interactions on Discord.
v0.2.11 Feb 6, 2024 · issue -381

AutoGen v0.2.11 adds FSM-based group chat, sequential multi-chat chaining, and AutoGen Studio workflow export and skill editing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.11 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.11
```
- ›Adds initiate_chats interface on ConversableAgent for programming a sequence of dependent chats that carry previous chat results forward.
- ›Adds FSM (finite state machine) based group chat via graph group chat support, enabling fine-grained control of speaker order transitions in group chat.
- ›AutoGen Studio gains workflow export, skill editing, and CSV support.
- ›Enables timeout for code execution on Windows using ThreadPoolExecutor.
- ›Every agent in a group chat now receives the termination message, not just the initiating agent.
└──▷ BREAKING ON UPGRADE
- !Default code execution is now disabled on society_of_mind and web_surfer agents.

v0.2.10 Feb 2, 2024 · issue -381

AutoGen v0.2.10 adds a Custom Model Client API, SocietyOfMindAgent, and tool-overwrite support for GPTAssistantAgent.

└──▷ GET THIS VERSION

$ git clone --branch v0.2.10 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.10

└──▷ USE IT

Wrap a custom inference backend so AutoGen agents can call it like any built-in model client.

python

from autogen import ConversableAgent

class MyCustomClient:
    def create(self, params):
        # call your own model endpoint here
        ...
    def message_retrieval(self, response):
        ...
    def cost(self, response):
        ...
    @staticmethod
    def get_usage(response):
        ...

agent = ConversableAgent(
    name='my_agent',
    llm_config={'model': 'my-model', 'model_client_cls': 'MyCustomClient'},
)
agent.register_model_client(model_client_cls=MyCustomClient)

Compose a more capable single agent from a multi-agent GroupChat using SocietyOfMindAgent.

python

from autogen.agentchat.contrib.society_of_mind_agent import SocietyOfMindAgent
from autogen import GroupChat, GroupChatManager, AssistantAgent, UserProxyAgent

inner_agents = [AssistantAgent('a1', llm_config=llm_config), AssistantAgent('a2', llm_config=llm_config)]
groupchat = GroupChat(agents=inner_agents, messages=[], max_round=6)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

society_agent = SocietyOfMindAgent('society', chat_manager=manager, llm_config=llm_config)
user = UserProxyAgent('user', human_input_mode='NEVER')
user.initiate_chat(society_agent, message='Solve this step by step: ...')

›Adds GPTAssistantAgent overwrite-tools functionality, letting callers replace the agent's registered tools at runtime.
›Adds Custom Model Client support, allowing developers to plug in arbitrary inference backends by implementing a defined client interface.
›Adds SocietyOfMindAgent, a new agent class that exposes a single-agent interface while running a full GroupChat as an internal monologue.
›Expands token_count_utils with support for new models.

└──▷ BREAKING ON UPGRADE

!The default value of code_execution_config in ConversableAgent is changed from None to False; any code that relied on the old None default to control code execution will behave differently after upgrade.

v0.2.9 Jan 28, 2024 · issue -382

AutoGen v0.2.9 adds GroupChat to AutoGen Studio, launches AutoGenBench, and enables agent-driven history cleaning in group chat.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.9 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.9
```
- ›Adds GroupChat support to the AutoGen Studio UI, enabling multi-agent group chat workflows without writing code.
- ›Introduces AutoGenBench, a new benchmarking tool for measuring and evaluating AutoGen agent performance.
- ›Adds (experimental) manual history cleaning in group chat, allowing agents (via user proxy) to send history cleaning commands mid-session.
- ›Adds a new notebook example for a SQL agent operating in the Spider environment.
v0.2.8 Jan 23, 2024 · issue -382

AutoGen v0.2.8 adds Redis caching, a web surfer agent, and human-input initiate_chat with no message required.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.8 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.8
```
└──▷ USE IT
Kick off a multi-agent conversation that prompts a human for the opening message instead of hard-coding one.
python
```
human_proxy.initiate_chat(assistant)
```
- ›Adds Redis cache support (alongside existing diskcache) for agent chat and LLM client inference via initiate_chat and client-level caching APIs.
- ›Allows initiate_chat to be called without passing a message, enabling the agent conversation to begin with human input instead.
- ›Adds a new web surfer agent capable of searching and browsing the web autonomously.
- ›Adds a dev container for AutoGen Studio to streamline development environment setup.
└──▷ BREAKING ON UPGRADE
- !use_docker now defaults to True; setups that previously relied on the False default will begin attempting to run code in Docker containers.
- !last_n_messages now defaults to 'auto'; setups that relied on the previous numeric default may see different conversation-context truncation behavior.
v0.2.7 Jan 18, 2024 · issue -382

AutoGen v0.2.7 adds Python 3.12 support, tag-based LLM config filtering, agent usage summaries, and AzureOpenAI endpoint compatibility.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.7 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.7
```
- ›Adds tag support to OAI_CONFIG_LIST entries, enabling filter_func or config selection to filter LLM configurations by tag.
- ›Switches to the AzureOpenAI client automatically when api_type == 'azure' is set in the config, replacing the legacy Azure path.
- ›Adds usage summary tracking for agents, surfacing token and call statistics per agent.
- ›Supports function call style API in the function decorator, enabling compatibility with Azure OpenAI and Gemini function-calling conventions.
- ›Adds Python 3.12 support.
+1 moreshow less
- ›Enables running sync reply functions inside async chats, broadening mixed sync/async agent composition.
└──▷ BREAKING ON UPGRADE
- !In the next release (not this one), the default value of use_docker in code_execution_config will change to True; set it to False or None explicitly now to avoid docker being enabled automatically on upgrade.
v0.2.6 Jan 11, 2024 · issue -382

AutoGen v0.2.6 adds streaming tool call support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.6 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.6
```
- ›Adds support for streaming tool calls, enabling real-time output as tool invocations execute.
v0.2.5 Jan 8, 2024 · issue -382

AutoGen v0.2.5 adds streamed function call support and makes contrib/capability directly importable.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.5 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.5
```
- ›Makes contrib/capability importable as a package by adding __init__.py, enabling direct imports from autogen.agentchat.contrib.capability.
- ›Adds support for streamed function calls, allowing agents to handle function-call responses delivered via streaming APIs.
v0.2.4 Jan 8, 2024 · issue -382

AutoGen v0.2.4 adds teachability for any agent, OpenAI tool-call support, and AutoBuild agent-library construction.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.4 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.4
```
- ›Adds OpenAI tool-call support to conversable agents, enabling agents to invoke tool calls returned by the API.
- ›Introduces a generic extensibility mechanism that lets any conversable agent become teachable — not just built-in agent types — as demonstrated by the new GPTAssistantAgent teachability example.
- ›Extends AutoBuild to support building agents from an agent library and auto-generating agent descriptions for group chat.
└──▷ BREAKING ON UPGRADE
- !GPT-4 is no longer the default model; callers that relied on the implicit default will now receive an error — the model must be set explicitly whenever an LLM is used.
v0.2.3 Jan 5, 2024 · issue -382

AutoGen v0.2.3 adds a function-calling decorator, AgentOptimizer, and renames AutoGen Assistant to AutoGen Studio.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.3 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.3
```
- ›Adds allow_repeat_speaker parameter support for a list of agents in group chat, enabling fine-grained control over which agents may repeat turns.
- ›Adds AgentOptimizer, a new class providing an agentic approach to iteratively train and improve LLM agent function sets.
- ›Adds a decorator for function calling, making it easier to define and register callable functions for agents.
- ›Improves config_list_from_json utility for loading model configuration lists, with an explicit error thrown when OAI_CONFIG_LIST is missing.
- ›Renames the AutoGen Assistant sample app to AutoGen Studio, with feature upgrades including multiline string support in chat input.
+5 moreshow less
- ›Adds Guidance + AutoGen integration example for constrained generation combined with multi-step reasoning.
- ›Adds a sample notebook for using AutoGen inside Microsoft Fabric.
- ›Adds poetry setup support for dependency management.
- ›Updates get_max_token_limit with latest models and token limits.
- ›Allows specifying a Docker image to use with Testbed via user configuration.
v0.2.2 Dec 10, 2023 · issue -383

AutoGen v0.2.2 adds async group chat, agent description field, and broader GroupChat message sourcing
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.2 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.2
```
- ›Adds a description field to agents, distinct from system_message, to improve speaker selection quality in group chat scenarios.
- ›Enables GroupChat to receive messages from agents that are not participants in the chat.
- ›Supports async group chat and async generation, enabling non-blocking multi-agent workflows.
- ›Raises an explicit error when a function/tool-use llm_config is passed to GroupChatManager, preventing misconfiguration.
- ›Changes the default model and config loading process in AgentBuilder.
+1 moreshow less
- ›Adds a new example notebook demonstrating video transcript translation with Whisper inside AutoGen.
└──▷ BREAKING ON UPGRADE
- !Fixes a breaking change introduced by openai>=1.1.0 in function call handling — users on v0.2.0 or v0.2.1 must upgrade.
v0.2.1 Dec 6, 2023 · issue -383

AutoGen v0.2.1 adds AutoBuild, Function Inception, async human input, and verbose GPT assistant logging.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.1 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.1
```
└──▷ USE IT
Enable verbose logging on a GPT assistant agent to surface detailed execution output during debugging.
python
```
from autogen.agentchat.contrib.gpt_assistant_agent import GPTAssistantAgent

agent = GPTAssistantAgent(
    name="analyst",
    llm_config={"config_list": config_list},
    verbose=True
)
```
- ›Adds a verbose flag to the GPT assistant agent to print more detailed logs during execution.
- ›Enables agents to register async human input handlers, supporting non-blocking input flows.
- ›Introduces Function Inception: agents can now define, update, or remove functions dynamically during a conversation after agent creation.
- ›Adds AutoBuild for automatically constructing multi-agent systems from a task description.
- ›Adds cost calculation and cost summary to the client-based inference layer, restoring a v0.1 capability.
+6 moreshow less
- ›Raises a content_filter error when responses are blocked by the content filter, restoring v0.1 behaviour in the new client.
- ›Adds is_termination_msg handling to GroupChat, enabling termination conditions in multi-agent group conversations.
- ›Message content field in agents now supports both str and List, generalizing the data structure to accommodate GPT-4V message format.
- ›Adds the GAIA benchmark to the Testbed for evaluating general AI assistants.
- ›Testbed can now read authentication credentials from the OPENAI_API_KEY environment variable in addition to OAI_CONFIG_LIST.
- ›Adds a warning message in retrieve chat when docs_path is not explicitly set.
└──▷ BREAKING ON UPGRADE
- !The openai dependency is capped at <1.3 as a temporary fix for the breaking change introduced by openai 1.3.
v0.2.0 Nov 25, 2023 · issue -384

AutoGen v0.2.0 adds GPTAssistantAgent, TeachableAgent, CompressibleAgent, AgentEval, multimodal (GPT-4V) support, and streaming to its multi-agent framework.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.0 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.0
```
- ›Adds GPTAssistantAgent leveraging the OpenAI Assistant API for conversational capabilities and state management.
- ›Adds TeachableAgent for persistent user teachings across chat sessions using a memo store.
- ›Adds experimental CompressibleAgent for managing long conversations that exceed context limits.
- ›Introduces the AgentEval framework for assessing task utility in LLM-powered applications.
- ›Adds support for customized vector databases and embedding functions in RetrieveChat RAG pipelines.
+10 moreshow less
- ›Adds support for custom text splitters in RetrieveChat.
- ›Adds function-call filtering in group chat to control which agents receive function-call messages.
- ›Adds experimental streaming support for agent responses.
- ›Adds enhanced async function execution and improved handling of human input.
- ›Adds Large Multimodal Model (GPT-4V) support to AgentChat.
- ›Adds a Langchain tool bridge enabling agents to use Langchain tools directly.
- ›Adds rich text format support in RetrieveChat and PDF file parsing via retrieve_utils.py.
- ›Adds richer speaker selector options and robustness improvements to GroupChat.
- ›Adds config_list instantiation from a .env file in openai_utils.py.
- ›Deploys a sample web application (autogen-assistant) for end-to-end demonstration of AutoGen agents.
└──▷ BREAKING ON UPGRADE
- !AutoGen v0.2.0 switches from openai v0.x to openai v1.x; existing code using the old client API will break and requires following the migration guide at https://microsoft.github.io/autogen/docs/Installation/#migration-guide-to-v02.
v0.1.14 Oct 28, 2023 · issue -385

AutoGen v0.1.14 adds multimodal LLaVA support, Qdrant vector store, thread-safe code execution, and token count utilities.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.14 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.14
```
└──▷ USE IT
Use Qdrant as the vector store backend for a retrieval-augmented agent in place of the default ChromaDB.
python
```
from autogen.agentchat.contrib.qdrant_retrieve_user_proxy_agent import QdrantRetrieveUserProxyAgent

ragent = QdrantRetrieveUserProxyAgent(
    name="qdrant_rag",
    retrieve_config={
        "docs_path": "./docs",
        "collection_name": "my_collection",
    },
)
```
- ›Adds QdrantRetrieveUserProxyAgent in contrib/ for Qdrant vector store support in retrieval-augmented chats.
- ›Adds token_count_util for counting tokens in agent conversations.
- ›Enables multimodal agent interactions via a new LLaVA example notebook at notebook/agentchat_lmm_llava.ipynb.
- ›Supports running agent chats in a different thread or process using thread-safe timeout for code execution.
- ›Supports the new version of chromadb in retrieve chat.
v0.1.13 Oct 21, 2023 · issue -385

AutoGen v0.1.13 adds TeachableAgent for persistent long-term memory across chat sessions via vector database.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.13 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.13
```
- ›Adds TeachableAgent class that persists user-taught facts, preferences, and skills across chat boundaries using a vector database, saving memos to disk at chat end and loading them at the next chat start.
- ›Retrieves individual memos into context as needed rather than loading the full memory store, preserving context-window space while enabling long-term recall.
v0.1.12 Oct 19, 2023 · issue -385

AutoGen v0.1.12 adds custom text splitter support for RAG agents and function call filtering in group chat.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.12 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.12
```
- ›Adds function call filtering in group chat, reducing failures when agents invoke tools during multi-agent conversations.
- ›Adds support for custom text splitters in RAG agents, enabling user-defined chunking logic for retrieval workflows.
v0.1.11 Oct 17, 2023 · issue -385

AutoGen v0.1.11 adds a Langchain tool bridge, enabling agents to use Langchain tools directly.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.11 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.11
```
- ›Adds a Langchain tool bridge so AutoGen agents can use Langchain tools natively, demonstrated in agentchat_langchain.ipynb.
- ›Improves logging in oai.completion to display token_count during model calls.
- ›Adds compatibility for custom models that do not return all fields in the response.
v0.1.10 Oct 10, 2023 · issue -385

AutoGen v0.1.10 lets you plug in customized vector databases and embedding functions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.10 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.10
```
- ›Adds support for plugging in customized vector database backends and custom embedding functions.
v0.1.7 Oct 7, 2023 · issue -385

AutoGen v0.1.7 adds .env file support for instantiating config_list in openai_utils.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.7 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.7
```
- ›Adds .env file support to openai_utils.py for instantiating config_list, enabling credential loading from environment files without hardcoding values.
v0.1.5 Oct 1, 2023 · issue -385

AutoGen v0.1.5 adds PDF file parsing support to RetrieveChat's retrieve_utils.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.5 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.5
```
- ›Adds PDF file parsing to retrieve_utils.py, enabling RetrieveChat to extract and index text from PDF documents.
v0.1.4 Sep 30, 2023 · issue -386

AutoGen v0.1.4 adds configurable retry timing for rate-limit handling.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.4 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.4
```
- ›Adds configurable retry wait time to handle API rate-limit errors in multi-agent workflows.
v0.1.2 Sep 27, 2023 · issue -386

AutoGen v0.1.2 adds single-line code detection and new RetrieveChat controls including customized_answer_prefix and no_update_context.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.2 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.1.2
```
- ›Adds customized_answer_prefix parameter to RetrieveChat to trigger Update Context when the specified prefix is absent from the answer, enabling custom trigger-word control.
- ›Adds no_update_context parameter to RetrieveChat to suppress Update Context entirely.
- ›Extends extract_code to detect single-line code blocks.
- ›RetrieveChat now upserts to ChromaDB in batches of 40,000 records, improving stability for large corpora.

Microsoft AutoGen

Summary

What Microsoft AutoGen answers

Features

command line

command line

command line

command line

Examples

Command line

Release history