Conversational Orchestration

One-Line Summary: Conversational orchestration — the AutoGen pattern — coordinates multiple agents through a multi-turn dialogue rather than dispatch-and-return: agents take turns speaking in a shared transcript, with a moderator deciding who goes next, and agreement emerges from the conversation itself.

Prerequisites: Topology as a design decision, sub-agents as primitives

What Is Conversational Orchestration?

In supervisor / queen-led topologies, the unit of coordination is dispatch: a worker is given a task, runs to completion, returns. In conversational orchestration the unit is a turn: each agent speaks once and stops; another agent speaks next; the conversation continues until consensus or budget exhaustion.

AutoGen pioneered this style with ConversableAgent and GroupChatManager. The user posts an initial task; the manager picks the next speaker; that speaker contributes; the manager picks the next; repeat. Speakers can be selected by round-robin, by a manager LLM, or by a registered policy. The result is a transcript that any participant can read, that captures the negotiation in full, and that can be replayed or audited.

How It Works

In an AutoGen group chat:

manager = GroupChatManager(
    groupchat=GroupChat(
        agents=[planner, coder, reviewer, user_proxy],
        messages=[],
        max_round=20,
        speaker_selection_method='auto'  # manager LLM picks
    )
)
manager.initiate_chat(message="Build a CLI for Slack messaging")

The manager is an LLM that, on each turn, reads the recent transcript and outputs the name of the next speaker. The chosen agent reads the transcript, generates a contribution, and the loop continues. Termination: the manager outputs TERMINATE, or the round limit is hit, or a registered termination function fires.

Why It Matters

Conversational orchestration shines for tasks where the form of agreement is itself part of the work: design discussions, debates, plan refinement, ambiguous decisions where you want multiple perspectives in dialogue. It struggles for tasks with a clear decomposition — there, supervisor or queen-led is more efficient.

The transcript is also a first-class asset. It captures the reasoning chain in a form humans can read, which is more debuggable than the dispatch-and-aggregate pattern's hidden internal states.

Key Technical Details

• Speaker-selection methods: round-robin (cheapest, dumbest), auto (manager LLM, smartest, most expensive), manual (human-in-the-loop), custom (your code).
• Round limits are mandatory: Without one, conversational systems can chat indefinitely.
• Termination patterns: explicit TERMINATE in a message; max rounds; registered is_termination_msg callback.
• Privacy and verbosity: Every agent sees the full transcript. Long transcripts are expensive (token cost grows linearly).
• User-as-agent: The pattern naturally accommodates a UserProxyAgent — a human in the loop.
• Memory across conversations: AutoGen has add-on memory libraries (mem0, memori); native memory is per-conversation.
• Tools are per-agent: Each agent registers its own tools; tools are not shared.

How Harnesses & Frameworks Implement This

Connections to Other Concepts

• role-based-orchestration.md — Conversational orchestration usually combines with role-based personas.
• supervisor-pattern-deep-dive.md — The dispatch-style alternative.
• topology-selection-decision-tree.md — When conversational is right.
• ../../ai-agent-concepts/05-multi-agent-systems/inter-agent-communication.md — Foundational coverage.

Further Reading

• AutoGen / AG2, GroupChat documentation.
• Microsoft Research, "AutoGen: Enabling Next-Generation LLM Applications" (2023) — The original paper.