Multi-Agent Systems with Microsoft AutoGen

The model: agents in conversation essential

Picture the difference between a factory and a meeting. In M1, CrewAI gave you a factory: work moves down an assembly line, each specialist does their station's job in a fixed order, and the output falls off the end. AutoGen throws that away and hands you a meeting room instead — you put a few experts around a table, give them a problem, and let them talk. Nobody's turn is pre-scripted; the conversation itself is the computation. That single shift in metaphor is why AutoGen feels so different, and why it can solve open-ended problems a rigid pipeline can't.

Here's why the meeting metaphor matters in practice: a pipeline can only do what you wired it to do, in the order you wired it. A conversation can double back — the reviewer sends the coder back to fix line 3, the coder revises, the reviewer looks again. That back-and-forth loop is trivial in AutoGen (it's just more messages) but awkward to express as a fixed line. When your problem is genuinely iterative — draft, critique, revise; brainstorm, challenge, refine — conversation is the natural shape.

The mistake almost everyone makes first is forgetting that a real meeting ends — someone eventually says "great, we're done." An AutoGen conversation has no such instinct. Two polite LLM agents will thank each other, agree with each other, and offer one more helpful suggestion… forever, quietly burning tokens the whole time. So the load-bearing idea to hold onto from the very first sentence is this: you don't just define who's in the room, you define when the meeting is over. That's the termination condition, and it's the piece beginners skip and regret.

In AutoGen, work happens through messages between agents. You define agents, put them in a team with a conversation pattern, give it a task, and the agents talk until a termination condition fires. The core participants:

Lab M2.1 · A two-agent conversation essential

shellpip install -U "autogen-agentchat" "autogen-ext[anthropic]"

pair.pyimport asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import TextMentionTermination
from autogen_ext.models.anthropic import AnthropicChatCompletionClient

model = AnthropicChatCompletionClient(model="claude-opus-4-8")

coder = AssistantAgent("coder", model_client=model,
    system_message="Write Python. Revise based on review feedback.")
reviewer = AssistantAgent("reviewer", model_client=model,
    system_message="Review the code. When it's correct, reply exactly 'APPROVED'.")

# stop when 'APPROVED' appears OR after 8 messages — always bound it two ways
term = TextMentionTermination("APPROVED")
team = RoundRobinGroupChat([coder, reviewer], termination_condition=term)

async def main():
    await team.run(task="Write a function that returns the nth Fibonacci number.")

asyncio.run(main())

Lab M2.2 · Teams of three+ (who speaks next?) essential

Two agents never have to wonder whose turn it is — with three or more, that question is suddenly the whole game. Think about a two-person conversation: it can only ping-pong, A then B then A, so "who speaks next" answers itself. Now put five people in a meeting. If everyone talks in a rigid clockwise circle, the person with nothing useful to add still burns everyone's time when their slot comes around. If instead a good chair watches the discussion and calls on whoever's expertise the moment needs, the meeting moves twice as fast. AutoGen makes you pick which kind of meeting you're running — and that choice is called speaker selection.

Why does this deserve its own section rather than being an afterthought? Because speaker selection is exactly where AutoGen touches the topologies you met in L1. A fixed rotation is the simplest possible coordination — sequential collaboration, no brains required. Letting a model choose the next speaker is the supervisor/router pattern: an LLM reading the room and dispatching to the right specialist. The same abstract shapes you drew as boxes-and-arrows in L1 show up here as one constructor argument. Getting this choice right is the difference between a team that converges and one that flails.

The trap here is subtle and it bites people who reach for the "smart" option too early. A model-driven selector sounds strictly better than a dumb rotation — let the AI decide! — but it can only choose well if the agents have clearly distinguishable roles. Give it a "planner", a "coder", and a "reviewer" with sharp, non-overlapping system messages and it routes beautifully. Give it three vaguely-worded generalists and it picks more or less at random, wasting turns and money while looking sophisticated. The rule of thumb: a selector is only as good as the role descriptions you feed it, so earn the complexity — start with round-robin, and upgrade to a selector only once your roles are genuinely distinct.

Beyond two agents, the key question is speaker selection: who talks next? AutoGen gives you patterns for this — the difference between L1's network (free-for-all) and supervisor (a chooser) topologies.

selector.pyfrom autogen_agentchat.teams import SelectorGroupChat
from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination

planner  = AssistantAgent("planner",  model_client=model, system_message="Break the task into steps.")
coder    = AssistantAgent("coder",    model_client=model, system_message="Implement the current step.")
reviewer = AssistantAgent("reviewer", model_client=model, system_message="Review; say 'DONE' when complete.")

# selector uses a model to choose the next speaker each turn (supervisor-style)
term = TextMentionTermination("DONE") | MaxMessageTermination(20)   # combine conditions
team = SelectorGroupChat([planner, coder, reviewer], model_client=model,
                         termination_condition=term)

Lab M2.3 · Tools & a human in the loop intermediate

A conversation, no matter how clever, is still just talk until someone can actually do something. Up to now our agents have been debating in a sealed room — they can reason and critique, but they can't look up today's stock price or run the code they just wrote. Two additions break the agents out of that room: tools (plain Python functions an agent may call) turn talk into action, and a human participant puts a real person in the loop as one of the speakers. Together they're what separate a chatty demo from something you'd trust to touch the real world.

The tool idea should feel familiar — it's the same tool-calling you built in the agents chapter, just happening inside a multi-agent conversation now. Here's the mental model that makes it click: an agent's tools are like the reference books and instruments an expert keeps within reach at the meeting. When the analyst needs a number it doesn't have, it doesn't guess and bluff — it reaches for the get_stock function, reads off the real value, and continues. The function's docstring is how the model knows when to reach for that particular book, so a vague or missing docstring is the most common reason a tool never gets called.

The human participant is the part worth slowing down on, because it's where safety lives. AutoGen's UserProxyAgent is genuinely two-faced: it can be a real person prompted at the keyboard, or an automated stand-in that auto-replies and even executes code on the agents' behalf. That second mode is exactly why AutoGen earned its reputation for code-writing loops — an assistant proposes code, the proxy runs it and reports the result, and they iterate. But it's also the trap: an auto-executing proxy with no sandbox will cheerfully run whatever the model dreamed up. The discipline is the same one this whole course repeats — a person is one of the speakers precisely so that anything irreversible pauses for a human "yes" first. This is L5's human-in-the-loop gate, expressed here as "a human is simply one of the participants in the chat."

AutoGen agents take tools (Python functions), and a human participant can join the conversation — the human-in-the-loop gate from L5, expressed as "a person is one of the speakers."

tools_human.pyfrom autogen_agentchat.agents import AssistantAgent, UserProxyAgent

def get_stock(ticker: str) -> str:
    """Get the latest price for a ticker."""
    return f"{ticker}: $123.45"

analyst = AssistantAgent("analyst", model_client=model,
    tools=[get_stock],                       # a Python function becomes a tool
    system_message="Use tools to get real data; never guess prices.")

# the human joins as a participant — asked to weigh in before finalizing
human = UserProxyAgent("human", input_func=input)   # prompts a real person at the console

team = RoundRobinGroupChat([analyst, human], termination_condition=term)

AutoGen vs CrewAI vs LangGraph intermediate

Common pitfalls advanced

Exercises advanced

def turn(agent_name, msg):
    return {"from": agent_name, "content": msg}

conversation = []
conversation.append(turn("assistant", "Here is a draft plan."))
conversation.append(turn("reviewer",  "Looks good, tighten step 2."))
conversation.append(turn("assistant", "Revised step 2."))

for m in conversation:
    print(f"{m['from']:10}: {m['content']}")

def should_stop(messages, max_messages=6, stop_word="TERMINATE"):
    if len(messages) >= max_messages:
        return "hit message cap"
    if messages and stop_word in messages[-1]["content"]:
        return "stop word seen"
    return None

def run(scripted_replies, max_messages=6):
    msgs = []
    for reply in scripted_replies:
        msgs.append({"content": reply})
        reason = should_stop(msgs, max_messages)
        if reason:
            return msgs, reason
    return msgs, "ran out of scripted turns"

msgs, why = run(["work...", "more work...", "done TERMINATE", "never reached"])
print(len(msgs), "messages; stopped:", why)   # 3 messages; stop word seen

def round_robin(agents, max_turns=5):
    transcript = []
    for i in range(max_turns):
        speaker = agents[i % len(agents)]      # cycle through the team
        transcript.append((speaker, f"turn {i+1}"))
    return transcript

for who, what in round_robin(["planner", "coder", "reviewer"]):
    print(who, "->", what)
# planner, coder, reviewer, planner, coder ...

AGENTS = {"coder": ["code", "bug", "implement"],
          "researcher": ["find", "source", "data"],
          "reviewer": ["review", "check", "approve"]}

def select_next(last_message):
    low = last_message.lower()
    for agent, keywords in AGENTS.items():
        if any(k in low for k in keywords):
            return agent
    return "reviewer"          # default when unsure

print(select_next("please implement the fix"))   # coder
print(select_next("find data on latency"))         # researcher
print(select_next("does this look done?"))          # reviewer

RISKY = {"deploy", "delete", "spend"}

def user_proxy(proposal, auto_approve_safe=True):
    action = proposal.get("action", "")
    if action in RISKY:
        return {"decision": "ASK_HUMAN", "why": f"'{action}' is risky"}
    if auto_approve_safe:
        return {"decision": "AUTO_APPROVE"}
    return {"decision": "ASK_HUMAN"}

print(user_proxy({"action": "summarize"}))   # AUTO_APPROVE
print(user_proxy({"action": "deploy"}))       # ASK_HUMAN

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.conditions import TextMentionTermination, MaxMessageTermination
# from autogen_ext.models.openai import OpenAIChatCompletionClient  # or another client

# model_client = OpenAIChatCompletionClient(model="...")  # your provider

writer = AssistantAgent("writer", model_client=model_client,
                        system_message="Draft a short answer.")
reviewer = AssistantAgent("reviewer", model_client=model_client,
                          system_message="Critique, then say TERMINATE when good.")

# two independent brakes: a stop word OR a hard message cap
termination = TextMentionTermination("TERMINATE") | MaxMessageTermination(8)
team = RoundRobinGroupChat([writer, reviewer], termination_condition=termination)

# import asyncio; asyncio.run(team.run(task="Explain vLLM in two sentences."))

Knowledge check check yourself