How Agents Communicate

In a single-agent system, everything the model needs lives in one context window. The moment you split work across agents, you introduce a boundary — and every boundary is a place where information must be packaged, transmitted, and unpacked. The quality of your multi-agent system is decided far more by what crosses those boundaries than by how clever any individual agent is.

This is counterintuitive. Teams reach for multi-agent architectures expecting more capability, then discover their bottleneck is coordination. The 2025 MAST study (UC Berkeley et al., 1,600+ annotated traces across 7 frameworks) found that the dominant causes of failure were inter-agent misalignment and specification issues — not raw model capability. Agents reset conversations, propagated wrong assumptions, withheld information, and duplicated each other's work.

Three mechanics carry information between agents: message passing (an agent sends a structured message to another), shared state (agents read and write a common workspace), and handoffs (an agent transfers control, along with context, to a specialist). Most production systems use all three. Master these and you control the variable that actually determines whether a multi-agent system works.

The most common mechanic is message passing: one agent sends another a structured message — natural language plus typed metadata — either directly (as a function/tool call) or through an orchestrator that routes it. This mirrors human delegation: a manager hands a worker a task with the relevant details attached.

The message is rarely just raw text. It carries metadata the receiver needs to act: the task, constraints, priority, and a place to put the result. A clean message contract is what keeps a system debuggable.

from pydantic import BaseModel
from typing import Literal

class AgentMessage(BaseModel):
    sender: str
    recipient: str
    task: str                       # what to do
    context: dict                   # only the relevant fields
    priority: Literal["low", "normal", "high"] = "normal"
    reply_to: str | None = None     # where the result goes

msg = AgentMessage(
    sender="orchestrator",
    recipient="research_agent",
    task="Find the 2026 pricing for competitor X's enterprise tier",
    context={"company": "X", "region": "EU"},
    priority="high",
)

Frameworks differ in framing. AutoGen (and its 2025 successor, Microsoft Agent Framework) treats agents as conversational participants exchanging chat messages in topologies like round-robin or nested group chats. OpenAI's Agents SDK and LangGraph treat inter-agent calls as tool invocations. Both are message passing; the difference is whether the model sees a conversation or a function call.

Message passing connects agents point-to-point. Shared state flips the model: instead of agents addressing each other, they read and write a common workspace. The classic form is the blackboard — a communal space where each agent posts findings and reads what others posted, asynchronously, with no direct peer-to-peer connection. Think of a whiteboard in a war room: nobody routes messages, everyone watches the board and contributes when they can help.

This decouples agents. A new specialist can be added without rewiring who-talks-to-whom; it simply watches the board for work it can do. A 2025 paper (arXiv:2510.01285) showed a blackboard system beating master–slave coordination by 13–57% on data-science benchmarks — decentralized, capability-based task pickup outperformed central routing.

The two patterns are not mutually exclusive, and the best systems combine them: an orchestrator uses message passing to delegate tasks, while all agents share a persistent state object to track progress.

In LangGraph this shared workspace is a typed State object persisted across nodes:

from typing import Annotated, TypedDict
from operator import add

class ResearchState(TypedDict):
    query: str
    findings: Annotated[list[str], add]   # each agent appends
    citations: Annotated[list[str], add]
    status: str

Each node receives the state, returns a partial update, and the framework merges it — the blackboard, made concrete.

A handoff is a special move: one agent doesn't just send a message, it transfers control to a specialist, along with the context that specialist needs. A triage agent recognizes a refund request and hands the conversation to the Refund Agent. The defining question of a handoff is not which agent receives control — it is how much context travels with it. That choice (next section) is the single biggest design decision in this lesson.

Frameworks implement handoffs differently:

• OpenAI Agents SDK (March 2025) exposes handoffs as tools the LLM can call. A handoff to the Refund Agent becomes a callable transfer_to_refund_agent tool. It provides input_filter to prune history, on_handoff callbacks to capture structured metadata (reason, language, priority), and a recommended prompt prefix to steer the model.
• LangGraph uses either conditional edges (add_conditional_edges() for static routing) or a Command object that updates state and names the next agent in one move, enabling dynamic handoffs.

from langgraph.types import Command
from typing import Literal

def triage_agent(state) -> Command[Literal["refund_agent", "support_agent"]]:
    intent = classify(state["messages"][-1])
    target = "refund_agent" if intent == "refund" else "support_agent"
    return Command(
        goto=target,
        update={"handoff_reason": intent, "priority": "high"},
    )

The Command both routes control and records why the handoff happened — exactly the metadata the next agent needs.

Think of a handoff like briefing a colleague who is taking over your task. You can dump every email you ever exchanged on them, hand them a tidy one-page summary, or fill out a short form with just the facts they need. The middle path is usually right — and the same is true for agents. Here is the decision that makes or breaks a multi-agent system: at each handoff, how much context do you transfer? There are three strategies, each with a sharp trade-off.

The naive default — forward the entire conversation — is deceptively expensive. A 50-message thread passed through four handoffs means the fifth agent processes roughly 200 messages, most irrelevant. Worse, long contexts dilute attention and reduce reliability. The framework-recommended approach is the structured context object: the orchestrator passes only the typed fields the receiver needs.

Context isolation is now a first-class principle. Anthropic's system spawns fresh subagents with clean contexts and maintains continuity through carefully written task descriptions — not full-history dumps. Each agent gets only what it needs to do its job.

# Structured object: pass relevant fields, not the whole transcript.
handoff_context = {
    "task": "Process refund for order #4471",
    "customer_tier": "enterprise",
    "order_total": 1299.00,
    "reason": "defective unit, verified",
}
# vs. forwarding 50 messages of small talk and unrelated tickets.

When a multi-agent system fails, the instinct is to blame the model — "it just isn't smart enough." That instinct is almost always wrong. The agents reason fine in isolation; they break at the seams between them, the same way a capable team fails when nobody writes things down or two people unknowingly do the same job. Most multi-agent failures are orchestration failures, not capability failures. The MAST taxonomy (arXiv:2503.13657) catalogued 14 failure modes across three clusters — specification issues, inter-agent misalignment, and task verification — from 1,600+ traces (κ=0.88). The communication-specific ones recur everywhere:

1. Wrong assumptions propagated — agent A states something uncertain as fact; agent B builds on it; the error compounds downstream.
2. Information withholding — an agent knows something relevant but never surfaces it across the boundary.
3. Conversation reset / context loss — a handoff drops the thread; the receiver re-derives or contradicts prior work.
4. Task derailment & duplicated work — vague task boundaries cause two agents to do the same thing, or drift off-goal. Anthropic's own system once spawned 50 subagents for a simple query.

A subtler 2026 finding (Silo-Bench) named the Communication–Reasoning Gap: agents can exchange information and form the right coordination topology, yet still fail because they don't correctly integrate the distributed state into the final answer. The wire worked; the synthesis didn't.

The fixes are mostly about discipline at the boundary: explicit, detailed task descriptions with output-format specs; typed message contracts that fail loud; passing structured context, not raw history; and clear task boundaries so agents don't overlap. Communication quality is an engineering practice, not a model property.