AutoGen — conversational multi-agent systems

Setup#

pip install autogen-agentchat autogen-ext

Written against autogen-agentchat 0.7. Careful with names: the modern packages are autogen-agentchat (the high-level chat API), autogen-core (the runtime) and autogen-ext (model clients and tools). The old package pyautogen and tutorials built on ConversableAgent belong to the 0.2 generation — a different API that will not match anything below. The install is modest by agent-framework standards, in the tens of megabytes.

AutoGen is async-first: everything runs inside asyncio. And like the other lessons in this section, the example uses a scripted model client — ReplayChatCompletionClient, which AutoGen itself provides for testing — so it runs offline, free, and identically on your machine.

A writer-editor team you can run#

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import MaxMessageTermination
from autogen_ext.models.replay import ReplayChatCompletionClient

# a scripted model client: it replays these answers in order,
# so the example runs offline and costs nothing
model = ReplayChatCompletionClient([
    "Idea: a lesson on how UPI fraud detection works.",
    "Feedback: good idea, but narrow it to one real fraud pattern.",
    "Revised: a lesson on how banks catch SIM-swap fraud in seconds.",
    "Feedback: approved.",
])

writer = AssistantAgent("writer", model_client=model,
                        system_message="You suggest lesson ideas.")
editor = AssistantAgent("editor", model_client=model,
                        system_message="You give blunt feedback on ideas.")

# agents speak in a fixed circle until the stop condition fires
team = RoundRobinGroupChat([writer, editor],
                           termination_condition=MaxMessageTermination(5))

async def main():
    result = await team.run(task="Propose one lesson for an AI learning site.")
    for msg in result.messages:
        print(f"{msg.source}: {msg.to_text()}")

asyncio.run(main())

user: Propose one lesson for an AI learning site.
writer: Idea: a lesson on how UPI fraud detection works.
editor: Feedback: good idea, but narrow it to one real fraud pattern.
writer: Revised: a lesson on how banks catch SIM-swap fraud in seconds.
editor: Feedback: approved.

For a real model, swap the client — for example OpenAIChatCompletionClient(model="gpt-4.1") from autogen_ext.models.openai, installed with pip install "autogen-ext[openai]" and an API key. Agents and team stay untouched.

Line by line, the parts that are not obvious#

RoundRobinGroupChat([writer, editor], ...) — the list order is the speaking order. The task message counts as the first message, from user; then writer, editor, writer, editor. With the limit at 5, the run stops exactly where you see it stop.

MaxMessageTermination(5) — termination conditions are objects, and they compose. MaxMessageTermination(20) | TextMentionTermination("APPROVED") stops on whichever fires first. That one line — a hard cap OR a success word — is the standard production pattern.

await team.run(task=...) — one call runs the whole conversation to termination and returns a result whose .messages is the transcript. There is also run_stream() for printing messages as they happen, which you will want for anything interactive.

msg.to_text() — messages are typed objects, not strings; .source says who spoke, .to_text() gives the readable content.

Why the transcript matters: the editor's "narrow it" message became part of the writer's context on its next turn — that is the entire mechanism. No routing code exists. Whatever is in the chat is what the next speaker sees.

Common mistakes#

Mixing API generations. Copying a ConversableAgent or initiate_chat snippet from an old blog into a 0.7 install fails on the first import. Before debugging anything, check which generation your tutorial is from: pyautogen imports mean 0.2, autogen_agentchat means the modern line.

No termination condition. Without one, the round-robin keeps circling until something else stops it. With a real model that something is your wallet. Set a cap on every team, even in experiments.

Forgetting the event loop. team.run(...) without await, or await outside an async function, gives you a coroutine object or a SyntaxError respectively. All AutoGen code lives under asyncio.run(...) somewhere.

One venv for every framework. Installing this lesson's frameworks together in one environment produces real dependency clashes — while preparing these lessons, autogen-core pinned protobuf to a 5.x version and CrewAI's install pulled in 6.x, breaking one of them. One virtual environment per framework saves an evening of pip archaeology.

Try it yourself#

Add a third agent, fact_checker, to the circle, extend the scripted replies so each agent gets a sensible line, and raise the message cap to 7. Then replace MaxMessageTermination(5) with TextMentionTermination("approved") and work out why the run now ends one message earlier than you expected — the answer teaches you exactly when conditions are checked.

What to learn next#

• MCP — the Model Context Protocol — the tool-connection standard every framework here now speaks.
• CrewAI — role-based agent teams — task pipelines instead of open conversation.
• LangGraph — agents as graphs — explicit control flow, the opposite design bet.