Briefs, Envelopes and Queues: How Agents Should Talk to Each Other
Agents never share a window, so every message between them is an interface. Pick the channel for the job, and check every result envelope before another agent reads it.
Written as at 21 August 2026.
agentic-aimulti-agent-systemsagent-communicationa2amcp
In a multi-agent system, no two agents share a context window. Whatever the researcher knows, the orchestrator learns only from what the researcher sends back. Every message between agents is therefore an interface, and it deserves the same care as any interface between services.
Many multi-agent failures start at a handover rather than inside a model: a summary that dropped its source, a result too large to read, a reply nobody can trace. This article covers the three channels agents use, the envelope a result should travel in, and the check it should pass on arrival.
Three channels do three different jobs
Agents talk through one of three channels, and most production systems combine the first two.
| Channel | Use it when | What it gives you | What it costs |
|---|---|---|---|
| Delegate call (an agent exposed as a tool) | Fan-out and fan-in inside one runtime | Simple, traceable, schema-checked; parent and child spans link naturally | The caller waits for its slowest worker; everything sits in one runtime and one trust domain |
| Shared state (task ledger plus artifact store) | Heavy outputs, dependencies between tasks, runs that must resume | Small windows, crash recovery, an audit trail, artifacts people can inspect | Schemas, versioning and concurrency control such as conditional writes and leases |
| Message bus or Agent2Agent (A2A) | Long-running, cross-team, cross-framework or cross-company agents | Loose coupling; workers built in any framework | Harder tracing, authentication between agents, and results that arrive eventually |
At Poly, the studio I am building, the lesson build uses the first two. The orchestrator sends each worker a brief as a delegate call, and each worker writes its full output to the artifact store under its own task prefix. The brief says what to do; the store holds what was done; the ledger records the state of each task. Fan-Out, Fan-In covers the brief. This article is about what comes back.
A result envelope is a contract, not a chat message
A worker’s reply should be a typed object, validated against a schema before the orchestrator reads a word of it. At Poly the researcher’s envelope carries seven fields:
- Status: done, failed or degraded, so the orchestrator branches in code rather than by interpreting prose.
- Summary: bounded in length, and the only part that enters the orchestrator’s window.
- Artifact URI: where the full output lives, so anything downstream can fetch it just in time.
- Sources: what the work rests on, and how many sources were quarantined along the way.
- Confidence: the worker’s own estimate, useful for routing but never proof.
- Usage: input tokens, output tokens and cost, so budgets are enforced from facts.
- Trust tag: for example
derived-from-untrusted-web, so the orchestrator knows the summary was shaped by content nobody vetted.
The trust tag earns its place. Greshake and colleagues showed that instructions hidden in retrieved content can steer an LLM-integrated application. A researcher that reads the open web will meet such content. The tag lets the orchestrator send that lesson to human review without having to judge the text itself.
Anthropic’s account of its research system makes the same point from the other side. Each subagent needs an objective, an output format, guidance on tools and sources, and clear task boundaries, otherwise agents duplicate work, leave gaps or miss information. The brief fixes the format going out; the envelope enforces it coming back.
Check every message at the door
The envelope is only a contract if something enforces it. Figure 1 shows the check I put in front of the orchestrator. Four tests run on every inbound message, whichever channel carried it:
- Schema. Does it validate against the expected type and version? Free prose fails.
- Trust tag. Is provenance declared? A missing tag is treated as untrusted, not as clean.
- Size. Is the summary within its bound? An oversized result is written to the artifact store and only a short summary goes forward.
- Trace context. Does it carry the run’s trace identifier? A result you cannot trace is a result you cannot debug or audit.
Each message ends in one of three places: accepted into the orchestrator’s window, stored as an artifact and referenced by URI, or quarantined for review and never read by a model. Every decision is written to the task ledger.
This check is a small instance of the Deterministic Shell / Probabilistic Core, the explanatory model at the centre of CAE: let the model reason inside the core, and make identity, schema and state transitions deterministic in the shell around it. The worker’s summary is probabilistic. Whether the orchestrator reads it is not. You can see the check stop an injected result in the prompt-injection scenario of the agent simulator.
MCP connects agents to tools; A2A connects agents to agents
The two protocols answer different questions. The Model Context Protocol standardises how an application exposes tools, resources and prompts to a model through MCP servers. The A2A protocol, now under the Linux Foundation, standardises how one agent delegates to another it cannot see inside: the remote agent publishes an agent card describing its capabilities, endpoint and authentication, and the client sends it tasks and receives status updates and artifacts. Most systems will use both.
Illustrative scenario: a fictional composite written to make the point concrete. It does not describe a real organisation, and its figures are not reported outcomes.
Picture a supplier onboarding team that calls a screening provider’s agent over A2A to check a new supplier’s directors against sanctions lists. The protocol carries the task. It does not decide whether the result is trustworthy, whether it carries your trace context, or whether it fits your schema. The door check still applies, perhaps more strictly, because the sender is outside your organisation.
What this does not solve
A well-formed envelope can still carry a wrong summary. Schema validation proves shape, not truth, so a separate evaluator still has to check claims against the artifact. Many queues deliver a message at least once, so every handler that causes a side effect needs an idempotency key. And a quarantine that nobody reviews is just a slower way to lose work: give it an owner and a service level.
Who does what
Executives: ask whether results from external agents are checked before your agents read them, and who owns the quarantine.
Architects: choose the channel per handover, not per system. Define the envelope schema, version it, and make the trust tag mandatory.
Engineers: validate every inbound message in code, propagate trace context across every channel, and send oversized results to the store automatically.
This article is part of The Agentic AI Architect, a series from the author of The Contextual Agentic Enterprise. Each piece matches a module of his course in development, Agentic AI Architect Pro.
References
- The Contextual Agentic Enterprise.
- Model Context Protocol specification. https://modelcontextprotocol.io/specification
- Agent2Agent (A2A) Protocol. https://a2a-protocol.org/
- Greshake, K. et al. (2023) "Not what you've signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection". https://arxiv.org/abs/2302.12173
- Anthropic (June 2025) "How we built our multi-agent research system". https://www.anthropic.com/engineering/multi-agent-research-system
Related
Fan-Out, Fan-In: How an Orchestrator Actually Delegates
An orchestrator delegates well only when each brief is a contract that code checks before dispatch, and each result comes back as a summary and a pointer.
The Orchestrator Should Never Read the Raw Material
Every turn re-reads the whole window, so the agent that plans should reason over summaries and pointers while workers read raw material in windows they throw away.
Why Enterprise AI Needs a Deterministic Shell
Don't try to make the model deterministic or simply trust it. Let it propose, and put identity, authority, schema, state and commitment in a shell that decides at the Commit Boundary.