A system where agents call each other directly is a system that seizes up the first time one agent is slow or down. The whole point of a mesh of autonomous agents is that they can work, scale, and fail independently - and that only happens if they communicate through events rather than direct calls. The hard part is not the bus; it is the discipline around what flows over it.
Events over calls
The foundational choice is that agents publish events about what happened and subscribe to events they care about, instead of invoking each other. When the vision agent finishes, it does not call the design agent; it publishes VisionDocumentCreated, and whatever cares - the design agent today, an analytics consumer tomorrow - reacts. This loose coupling is what lets you add, scale, or replace an agent without touching the others.
flowchart LR
vision[Vision Agent] -->|VisionDocumentCreated| bus[(Message Bus)]
bus --> design[Design Agent]
bus --> audit[Audit Consumer]
design -->|DesignCompleted| bus
The canonical envelope
The move that makes the mesh observable is wrapping every event in a single canonical envelope. The payload differs per event type, but the envelope is constant - and it always carries the ids that let you follow a unit of work across the whole system:
{
"messageId": "6f1c...",
"type": "VisionDocumentCreated",
"version": 2,
"traceId": "a1b2c3...",
"correlationId": "vision-2026-06-06-042",
"occurredUtc": "2026-06-06T10:15:00Z",
"payload": { }
}
The correlationId ties together every event produced while fulfilling one original request; the traceId links the events to distributed traces. With those two fields present on every message, reconstructing "what happened to request 042?" becomes a query instead of an archaeology project.
Versioning is not optional
Events are a contract between producers and consumers that deploy independently, so they will drift. The envelope carries an explicit version, and consumers tolerate unknown fields. That lets a producer add to a payload without breaking older consumers, and lets you introduce a v2 of an event alongside v1 during a migration. Skip versioning and your first schema change becomes a coordinated, all-at-once deploy - the exact thing event-driven architecture is supposed to avoid.
Idempotency and dead letters
At-least-once delivery is the norm, which means consumers will occasionally see the same event twice. Two mechanisms keep that safe:
- Idempotency - consumers key off
messageIdso processing the same event again is a no-op, not a duplicate side effect. - Dead-letter queues - a message that cannot be processed after retries is parked for inspection instead of blocking the queue or being lost.
Note: "Exactly once" is mostly a myth in distributed systems. Design for at-least-once delivery plus idempotent consumers, and you get the same practical guarantee without the fragility.
What the envelope buys you
With a consistent envelope, observability and operability come almost for free. You can trace a request end to end, replay a sequence of events to reproduce a bug, audit who did what, and route or filter by type and version - all without bespoke logic in each agent. The envelope is the small upfront tax that pays for every one of those capabilities.
Wrapping up
An agent mesh works because of two disciplines layered on a message bus: communicate through versioned events, and wrap every event in a canonical envelope carrying trace and correlation ids. Add idempotent consumers and dead-letter handling, and you get a system whose parts scale and fail independently while remaining fully observable and replayable. The bus is the easy part; the envelope and the discipline are what make it a system you can operate.
Designing an event-driven or agentic system? Let's design it together.
