Agent-to-Agent Communication Patterns

Agents that cannot talk to each other are just isolated tools. An autonomous company requires coordination, and coordination requires communication with structure.

The choice of communication pattern shapes everything downstream: reliability, latency, complexity, and failure modes. Pick the wrong pattern and you will spend more time debugging message flows than building capabilities.

The spectrum of agent communication

There are four broad patterns, in order of increasing complexity:

• Fire-and-forget — one agent sends a message and moves on. No response expected. Useful for logging, notifications, and non-critical updates. Simple but offers zero confirmation of receipt or action.
• Request-response — one agent sends a request and waits for a reply. The foundational pattern for task delegation and information queries. Straightforward but creates blocking dependencies.
• Negotiation — two or more agents exchange proposals and counterproposals to reach agreement. Required when agents have different objectives or constraints. More complex but necessary for resource allocation and priority resolution.
• Consensus — multiple agents must collectively agree before action proceeds. The heaviest pattern, used for high-stakes decisions where no single agent should have unilateral authority.

When to use each

Guidelines for pattern selection:

• Use fire-and-forget for status updates, telemetry, and audit logging
• Use request-response for task delegation, data retrieval, and simple approvals
• Use negotiation when agents manage competing priorities or scarce resources
• Use consensus for irreversible actions, large financial commitments, and policy changes

Default to the simplest pattern that meets the requirement. Complexity is a cost.

Handling failures and timeouts

Every communication pattern needs a failure strategy:

• Define timeouts for every request that expects a response
• Distinguish between "no response" and "negative response" — they require different handling
• Implement retry with backoff for transient failures
• Define fallback behavior when a required agent is unreachable
• Log all communication failures as first-class events, not swallowed exceptions

Schema design for agent messages

Agent messages should be structured, versioned, and validated:

• Use a consistent envelope (sender, recipient, timestamp, message type, correlation ID)
• Version your message schemas from the start — you will change them
• Include enough context in each message for the recipient to act without additional queries
• Keep payloads minimal but self-contained
• Define a standard error response format across all agents

Practical considerations

Things that matter in production:

• Message ordering is not guaranteed unless you enforce it — decide whether ordering matters for each channel
• Idempotency is essential — agents will receive duplicate messages and must handle them gracefully
• Observability requires correlation IDs that trace a conversation across multiple agents and multiple hops
• Back-pressure mechanisms prevent fast agents from overwhelming slow ones
• Dead letter handling ensures that undeliverable messages surface rather than vanish

The communication layer is the nervous system of an autonomous company. Build it with the same care you would give to the financial system, because eventually it will carry financial instructions.