The 3 Laws of Agentic Communication: A Visual Guide

You have decided you need a team. You have moved past the monolith agent and hired specialists. But suddenly your latency is spiking, your API bill is skyrocketing, and your agents are arguing over the same task.

The problem is not the brains of your agents. It is the cables between them.

In multi-agent design, the topology of the graph is the skeleton. The communication mechanism is the nervous system. Pick the wrong one and the coordination tax will bankrupt your performance before a single user complains.

Here is the visual guide to how agents actually talk, and when to use each.

1. Direct Handoff: the Relay Race

Agent A completes its task, packages the result, and hands it directly to Agent B. A classification agent identifies a document type and passes it to a processing agent with a typed summary: document category, confidence score, required fields, expected return format. No one else is involved.

The style is synchronous and linear. You always know who has the baton. Traces are clean, failures are local, and the orchestrator retains full visibility at every step.

The cost is rigidity. If the downstream agent is busy or the handoff payload is vague, the whole line stops. A worker mid-task cannot ask a follow-up question without interrupting the orchestrator’s loop. In most production systems that is a feature, not a bug. Workers should have enough context in their handoff to complete the assignment without back-channelling. If they do not, the handoff was underspecified.

Note: Without a typed schema, a handoff is not a transfer of work. It is a game of “I hope the next LLM understands my vibes.” In production, untyped handoffs are where roughly 80% of multi-agent failures originate. The receiving agent gets a prose paragraph when it expected a structured JSON object. Both agents executed correctly. The contract between them never existed. That is not an agent failure. That is an interface failure dressed up as one. Design your handoff schemas with the same discipline you apply to tool output schemas, before any worker fires.

Use this for pipelines and hierarchical systems where the execution path is predictable and control matters more than flexibility.

2. Shared Blackboard:

A central, mutable state store. Every agent reads from it and writes to it. No one talks to anyone directly. They update the board and move on. A coordinating agent checks what needs doing next without waiting for a ping. State accumulates naturally and the board serves simultaneously as a coordination medium and a progress log.

The style is asynchronous and pull-based. Agents work at their own pace, which is exactly why this mechanism earns its keep in long-running systems where no single agent owns the full picture.

The cost is twofold. First, concurrency. Two agents writing incompatible values to the same record both succeed. No error is thrown. The system now holds two truths about the same object, and every downstream decision built on that record may be wrong. Second, and this one hits your API bill directly: context bloat. If every agent reads the full board on every turn, you are paying for the same tokens five times over. A five-agent system reading a shared state store of 3,000 tokens per turn is burning 15,000 tokens in attention budget before a single useful decision is made. The blackboard is a powerful coordination tool. It is also one of the fastest ways to silently inflate your inference costs if you do not scope what each agent is allowed to read.

Use this for long-running systems where multiple agents need a shared, evolving view of the world, and enforce read-scoping from day one.

3. Message Passing: the Dispatch Radio

Agents broadcast events to a queue and move on immediately, without knowing or waiting for who picks them up. A processing agent announces that a batch is complete. Whoever is free to handle the next stage picks up the message. The sender does not know or care who that is.

The style is decoupled and push-based. You can add ten downstream agents without changing a single line of code in the upstream one. The sender and receiver only need to agree on the message format, not on each other’s existence.

The cost is observability. Causality is hard to trace without a complete event log. If something disappears in the pipeline, finding which broadcast went wrong is a debugging nightmare when your logs are incomplete.

The Observer Pattern. The practical fix is a passive Observer agent: a non-participating agent that monitors the message bus without writing to it. It reads every event, tracks causal chains, and flags anomalies, such as an agent consuming the same message twice, or a downstream agent that has gone silent after a specific broadcast. The Observer does not intervene. It watches and reports. This is the agentic equivalent of telemetry, and it turns an otherwise opaque event stream into a traceable audit log without adding coordination overhead to any of the active agents.

Use this for event-driven systems where agents are loosely coupled and throughput matters more than linear auditability. Add the Observer before you need it, not after your first production incident.

The Dose Verdict: the Minimal Context Principle

Choosing the right mechanism is half the job. The other half is what actually travels across it.

The most common mistake in multi-agent communication is passing the journey, not the conclusion. If Agent A consumed 15,000 tokens solving a problem, it should pass a 200-token structured summary to Agent B. The orchestrator needs the conclusion. It does not need the reasoning trace that produced it.

The rule of thumb is simple. Need auditability? Use direct handoffs with typed schemas. Need resilience across a shared world? Use a shared blackboard with read-scoping. Need scale without coupling? Use message passing with an Observer.

Get this wrong and you will spend your 2am debugging something that looks like an agent failure but is actually a communication failure. The agents will be innocent. The cables between them will not be.

📖 This scenario is drawn from The Agentic AI Book — a production-first guide to building AI systems that actually work.
Grab early access: book.ryanrad.org

Until next dose — Dr. Ryan Rad