Contextual Agentic

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.

·5 min read

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:

  1. Status: done, failed or degraded, so the orchestrator branches in code rather than by interpreting prose.
  2. Summary: bounded in length, and the only part that enters the orchestrator’s window.
  3. Artifact URI: where the full output lives, so anything downstream can fetch it just in time.
  4. Sources: what the work rests on, and how many sources were quarantined along the way.
  5. Confidence: the worker’s own estimate, useful for routing but never proof.
  6. Usage: input tokens, output tokens and cost, so budgets are enforced from facts.
  7. 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.

Animated diagram of messages between agents passing an envelope check. Three senders appear on the left: the researcher and the scriptwriter, both over a delegate call, and a partner evaluator reached as an agent-to-agent task. Each message passes four checks in turn: schema, trust tag, size and trace context. The researcher's result, an 850-token summary with a pointer, passes all four and is accepted into the orchestrator's window. The scriptwriter's result arrives with a 9.8 thousand token script inline; it passes schema, trust tag and trace but the size check flags it, so the script is stored as an artifact and only a short summary goes forward. The partner's result is free prose with no trust tag and no trace context, so it fails schema, trust tag and trace and is held in quarantine for review. Every decision writes a row to the task ledger.
Figure 1. Three messages, four checks, three outcomes. Every decision is written to the ledger. Animated; shown as a still image if your device is set to reduce motion.

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

  1. The Contextual Agentic Enterprise.
  2. Model Context Protocol specification. https://modelcontextprotocol.io/specification
  3. Agent2Agent (A2A) Protocol. https://a2a-protocol.org/
  4. 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
  5. Anthropic (June 2025) "How we built our multi-agent research system". https://www.anthropic.com/engineering/multi-agent-research-system

← All articles

Related