---
kind: concept
slug: agent-communication-protocol
title: Agent communication protocol
summary: >-
  How language-model agents find each other, exchange messages, tasks and artifacts, and route work. A valid protocol message does not give the sender authority over the task. One card-backed benchmark tests A2A, ANP and BCS and finds that entry-point breaches predict final harm poorly, and that a protocol-level guard cuts attacks at a completion cost.
tags: [agents, multi-agent, agent-security, agent-protocols, evaluation]
papers: ["2610.15529"]
related: [multi-agent-systems, llm-agent, tool-use, prompt-injection]
status: draft
updated_at: 2026-11-21
---

## Overview

An agent communication protocol defines how agents discover one another,
authenticate, send messages and hand over tasks or artifacts. The protocol
can check that a message is well formed and signed by a registered
participant. The paper's central point is that this is not the same as task
authority: the application must still decide whether that sender may affect a
given decision [arxiv:2610.15529 §1, §3.1].

The authors formalise this as one condition. An object is used for an action
only if it is valid under the protocol and allowed by the task contract. The
allowance part depends on role, contract, audience and context
[arxiv:2610.15529 §3.1, eq. 1]. The paper also checks validity again at reuse,
since an object authorised for one task, version, principal or session may be
invalid for another [arxiv:2610.15529 §3.3, tab. 5].

Influence through a multi-agent task is followed in six stages: entry, reach,
consume, propagate, decision and effect. An attack can stop at any of them
[arxiv:2610.15529 §4.5]. Most of the design questions below are about which
stage a defence sits at.

## Variants

The protocols evaluated in the one card-backed study are three. Each is a
different design point, so the card's results are per protocol.

### A2A

Peers are found through published agent cards. Messages, tasks and artifacts
are exchanged natively [arxiv:2610.15529 §5.3]. Card: [Agent-Canary-Mas](/papers/2610.15529).

### ANP

Identities are resolved, service descriptions are read, and endpoints are
called after authentication. The study uses a remote-agent mode for live
collaboration [arxiv:2610.15529 §5.3]. Its native records do not link a
request and its result to the agent that consumed the result
[arxiv:2610.15529 §6.2]. Card: [Agent-Canary-Mas](/papers/2610.15529).

### BCS

A central service tracks bots, sessions and message routing
[arxiv:2610.15529 §5.3]. Card: [Agent-Canary-Mas](/papers/2610.15529).

## Design checklist: five risk classes

The paper groups protocol risks by the lifecycle transition where a
decision is made. Each class has its own security question, and its 13
subclasses share one transition and one local check [arxiv:2610.15529 §3.3,
tab. 5]. For a new protocol design, these are the questions to answer:

| Class | Transition | Question to answer |
|---|---|---|
| T1 Identity Binding | admitting participants; keeping identity tied to actions | Who may join, and can later actions still be traced to them? |
| T2 Capability Integrity | advertised versus delivered capability; contract compliance | Do advertised capabilities match what is delivered? |
| T3 Routing Authorization | execution target, real audience, routes and branches | Who may receive a message, and who may steer the next step? |
| T4 Content Authority | remote data becoming a fact, an action, or a stored value | At what point does remote data start to control a local decision? |
| T5 Object Validity | validity over time; binding to the current context | Is a reused object still valid for the current task? |

The paper instantiates these for each protocol, giving 39 specifications
[arxiv:2610.15529 §4.2, tab. 6]. A design can use the list as a test plan
even without running the benchmark.

## Protocol-level guard

A guard checks an object at the discovery, routing, consumption and reuse
points of a protocol. It first uses the explicit identity, capability, routing
and lifecycle evidence. If that does not settle the question, a bounded
semantic check asks whether the asserted authority fits the task. The guard
then allows the use, narrows it, asks for a fresh check, or refuses the object
and falls back to a verified route. Restrictions carry into later handoffs
[arxiv:2610.15529 §5.4].

The paper describes the guard in prose only. It gives no thresholds, prompt or
rule that maps evidence to an outcome, so anyone building one must make those
choices [arxiv:2610.15529 §5.4].

## When to use which

Choose by the constraint that binds, and only claim what the cited results
support.

| Situation | Use | Why |
|---|---|---|
| You need to know which participant caused a failure | Record linked evidence across agents, not only per-protocol logs | Audit F1 rises from 29.7% with native records to 95.5% with the authors' retained view. Part of this gap comes from extra instrumentation, not the protocol alone [arxiv:2610.15529 §6.2, app. D] |
| Your ANP-style flow must trace a result to its consumer | Add the request-to-consumer link explicitly | Native ANP records score 0.0 F1 on attribution in the study, as they do not link request, result and consumer [arxiv:2610.15529 §6.2] |
| You can afford added latency and a semantic review call | A protocol-level guard at handoffs | On the Finance subset with MiniMax-M3, mean ASR falls from 86.1% to 53.8% and mean PTCR from 65.5% to 31.2% [arxiv:2610.15529 §6.3, tab. 4] |
| Task completion matters more than blocking every attack | Measure TCR beside ASR before deploying a guard | The same guard lowers mean TCR from 99.8% to 95.1%, and BCS T2 falls to 76.7% [arxiv:2610.15529 §7, tab. 4] |
| A single entry check is your only control | Do not rely on it | Local attack success is often at or above 90%, but the share with a downstream consequence ranges from 7.1% to 100.0% [arxiv:2610.15529 §6.1, tab. 3]. Checks at later stages still matter |

The paper's guard numbers come from 5 pairs per subclass per protocol, all in
the Finance domain [arxiv:2610.15529 §5.4]. Treat small differences as
unreliable.

## Implementation sketch

The sketch below shows the common core: the validity and allowance check at
each handoff, repeated at reuse. The paper's guard is described only in prose,
so the branch logic is an illustration, not the authors' algorithm
[arxiv:2610.15529 §3.1, §5.4].

```pseudocode
# Authorisation at one handoff: valid AND allowed  [arxiv:2610.15529 §3.1]
def authorise(obj, action, contract, context):
    # Validity: signature, credentials, schema and state  [§3.1]
    if not protocol_valid(obj, context):
        return "reject"
    # Allowance: role, contract, audience and context  [§3.1, eq. 1]
    if not task_allowed(obj, action, contract, context):
        # Restrict or ask for a fresh check; do not silently accept  [§5.4]
        return "restrict"
    return "allow"

# Validity is checked again at reuse, not only at creation  [§3.3]
def reuse(obj, new_context):
    return authorise(obj, "reuse", new_context.contract, new_context)
```

## Contradictions

None known across papers; only one card-backed source so far. Within the
card's source, the text and table disagree in two places, and the table should
be used for reimplementation checks:

- Mean PTCR for GLM-5.2 is given as 87.9% in the text, but the three Avg rows
  of tab. 3 give 88.0% [arxiv:2610.15529 §6.1, tab. 3].
- The text calls routing (T3) the lowest-ASR class for ANP and BCS at
  48.3% to 66.7%, but BCS T5 is 48.0% under MiniMax-M3, which is lower
  [arxiv:2610.15529 §6.1, tab. 3].

## Papers

- [Agent-Canary-Mas](/papers/2610.15529): a 975-pair benchmark over A2A, ANP and BCS that measures local attack success, downstream consequence, attribution and a protocol-level guard. All numbers are author-reported, and no official code was found.
