Conversational Multi-Agent Patterns: Agent-to-Agent Chat

Agent-to-agent chat is how AutoGen popularized multi-agent systems: specialists take turns on a shared conversation until a stop condition ends the run.

In Microsoft Agent Framework 1.0 those patterns live primarily as orchestration builders on the workflow stack (sequential, concurrent, Magentic, and related samples) rather than a separate Team runtime forever.

Summary

Structure specialists with distinct instructions and tools, choose sequential vs concurrent vs manager-led orchestration, stream events, and enforce round caps so chat cannot thrash.

Recipe

1. List real roles (writer, reviewer, researcher) and write one-sentence goals for each.
2. Create one chat client shared or per-role model tier as needed.
3. Build each Agent with unique name, instructions, and least-privilege tools.
4. Pick an orchestration shape: sequential turns, concurrent fan-out, or Magentic manager-led.
5. Set hard limits (max_round_count / stall limits where available; always budget tokens and wall time in the host).
6. Run with stream=True and log each participant message with author name.
7. Define success: final approved artifact, structured consensus, or escalated human review.
8. Only then add graph edges if you need typed joins, checkpoints, or formal HITL request/response.

Working Example

Sequential writer → reviewer conversation (Python shape - verify imports at build):

import asyncio
from typing import cast
 
from agent_framework import Agent, Message
from agent_framework.openai import OpenAIChatClient
from agent_framework.orchestrations import SequentialBuilder
 
 
async def main() -> None:
    client = OpenAIChatClient(model="gpt-4o")  # verify model id at build
 
    writer = Agent(
        client=client,
        name="writer",
        instructions="Write one punchy marketing sentence. No preamble.",
    )
    reviewer = Agent(
        client=client,
        name="reviewer",
        instructions="Critique the previous message in two short bullets.",
    )
 
    workflow = SequentialBuilder(participants=[writer, reviewer]).build()
    task = "Tagline for Microsoft Agent Framework 1.0."
 
    async for event in workflow.run(task, stream=True):
        if event.type == "output":
            for msg in cast(list[Message], event.data):
                who = msg.author_name or str(msg.role)
                print(f"[{who}]: {msg.text}")
 
 
if __name__ == "__main__":
    asyncio.run(main())

Concurrent specialists when branches do not need each other's intermediate text:

from agent_framework.orchestrations import ConcurrentBuilder
 
workflow = ConcurrentBuilder(participants=[legal_agent, pricing_agent, tone_agent]).build()
# Each participant processes the same input; aggregate outputs in your handler

Deep Dive

What "conversation" means here

Conversational multi-agent means agents share a message history and take turns (or parallel turns) as participants. It is different from a pure data-flow graph where executor A sends a typed payload to executor B without a chat transcript.

Use conversation when:

• Critique and revision improve quality (draft → review).
• Roles genuinely disagree or check each other.
• You want AutoGen-like collaboration with less custom glue.

Prefer a strict graph when:

• Steps are a fixed business process.
• You need deterministic joins, retries, or resume from checkpoint.
• Compliance requires an explicit path, not emergent chat.

Pattern catalog

Designing turn quality

• Role prompts: state output format ("two bullets", "JSON only") so the next agent has clean input.
• Stop conditions: max rounds, stall detection, manager reset limits, and host-level timeouts.
• Shared vs private tools: never give every participant the production deploy tool.
• Transcript hygiene: summarize long tool dumps before they re-enter the shared chat.

Mapping from AutoGen mental models

Exact class names and parameters can evolve; treat official samples as source of truth at build.

Gotchas

1. Identical specialists - two agents with the same prompt add cost without diversity.
2. Unbounded rounds - chat without max rounds is a burn rate bug.
3. Transcript bloat - dumping full tool JSON into shared history exhausts context.
4. Parallel tool races - concurrent patterns need explicit aggregation rules.
5. Assuming AutoGen Team APIs - expect workflow/orchestration APIs, not a perfect clone of every AutoGen class.
6. Missing author names - without name on agents, logs become unreadable multi-agent soup.
7. Using chat for ETL - deterministic pipelines belong in graph workflows with checkpoints.

Alternatives

FAQs

Related

• Microsoft Agent Framework Basics - first two-agent example
• Graph-Based Workflows in Microsoft Agent Framework - graph alternative
• From AutoGen and Semantic Kernel to Microsoft Agent Framework 1.0 - merger context
• Migrating an Existing AutoGen Project to Microsoft Agent Framework - Team → orchestration
• Microsoft Agent Framework Best Practices - production practices
• Multi-Agent Handoff: Specialist Agents Passing Work to Each Other - pattern-level handoff design

Stack versions: Pins from the category manifest (verify at build): OpenRouter (~315+ models, July 2026 pricing/fees); LangGraph 1.0+; CrewAI 1.14+; Microsoft Agent Framework 1.0; Vercel AI SDK 6; Pydantic AI (latest); LlamaIndex (latest); OpenAI Agents SDK (latest + MCP); MCP (Linux Foundation governance); A2A (HTTP+SSE+JSON-RPC 2.0); Solana @solana/web3.js + @solana/spl-token.