wikillm

Paper · 2026-10-11 · cs.AI

Agent-Canary-Mas: End-to-End Evaluation of Protocol Risk in Long-Horizon Multi-Agent Systems

Agent-Canary-Mas tests whether a deviation in an agent-to-agent protocol (A2A, ANP, BCS) changes a multi-agent task's outcome. It runs 975 matched malicious-benign task pairs with OpenClaw agents and three LLMs. Local attack success is often at or above 90%, but consequence conversion ranges from 7.1% to 100.0%. A protocol-context Guard lowers Finance ASR from 86.1% to 53.8%, at a completion cost.

Multi-agent systemsLLM agentAgent communication protocolmulti-agentagent-securityagent-protocolsevaluationbenchmark

arXivPDFMarkdown16 min read

AI-compiled by claude-haiku-5-5 on 2026-11-21, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

AI agents increasingly find each other, hand over results and call tools on a user's behalf. Protocols define how they do this. A message can pass every protocol check, be a valid message from a real participant, and still be misused later. For example, an agent may be sent to the wrong service, or trust a claim that the sender had no right to make.

The paper builds a test suite of paired tasks. In each pair, one version has a malicious participant and one does not, and everything else is the same. For each pair it records three things: whether the attack worked at the protocol step, whether a later agent acted on it, and whether the final result changed. It also records which agent was responsible, so the cause can be traced. A guard that checks whether a received object has the authority for the step where it is used is tested as a defence.

The main lesson is that a successful break at the entry point predicts the final harm poorly. Whether the damage happens depends on how later agents use what they received. Evidence that links the steps of a task makes it much easier to find the responsible participant.

TL;DR

Agent-Canary-Mas is a benchmark of 975 matched malicious-benign task pairs across three agent protocols (A2A, ANP, BCS) and five business domains, run with autonomous OpenClaw agents under three LLMs. Local attack success is often at or above 90%, while the share that becomes a task consequence ranges from 7.1% to 100.0% §6.1, tab. 3. Cross-agent evidence raises macro-averaged attribution F1 from 29.7% to 95.5% §6.2, fig. 4. On Finance tasks, a protocol-context Guard reduces ASR but also task completion §6.3, tab. 4. All numbers are author-reported.

Problem

Protocol validity is not task authority. A protocol can confirm who sent a message, but the application still has to decide whether that sender may influence a given decision §1, §3.1. Local deviations have no fixed downstream outcome, so measuring only local exploitability leaves open whether a deviation changes the task, and who caused it §1. The paper names prior work that covers parts of this: tool-attack benchmarks (AgentDojo, InjecAgent), multi-agent propagation studies (ConVerse, ACIArena) and protocol-focused studies (A2ASecBench, AIP-Bench, ProtocolBench) §1. The open question is whether a deviation that works at the entry point still matters once later agents act on it, and whether the evidence trail is good enough to name the participant at fault §1.

Method

Threat model

The attacker is an ordinary member of the protocol, holding only standard rights. It controls one credentialed agent or service endpoint and can only publish or return the objects and fields its role allows. It cannot see other agents' keys, system prompts, internal state or the evaluator's answer key. Each pair changes one registered property through a normal interface §3.2. Out of scope are stolen or forged credentials, breaking the cryptography or transport layer, taking over hosts, editing another agent's prompts or tools directly, coordinated cheating between participants, side-channel leaks, attacks on the software supply chain, and request floods meant only to exhaust capacity §3.2.

Authorization condition

A protocol object x is used with an action a if it is both valid for the protocol and allowed for the task. Validity is checked with signatures, credentials, schemas and state machines. Allowance depends on the role, the task contract, the audience and the context §3.1:

\mathsf{Auth}_{p,\Theta}(x,a) = \mathsf{Valid}_{p}(x) \land \mathsf{Allowed}_{\Theta}(x,a) eq. 1

Risk appears once an object that passes validity then has more effect than the task contract Θ allows for it §3.1. The paper checks validity again at reuse, not only at creation, so a previously authorized object can become invalid for a new task, version, principal or session §3.3, tab. 5.

Five risk classes and 13 subclasses

Five transitions in the protocol lifecycle each give a risk class. Each class has its own security question. The subclasses share one transition, one security question and one local oracle §3.3, tab. 5:

ClassNameSubclassesSecurity question tab. 5
T1Identity Bindingadmitting participants; keeping an identity tied to its actionsWho gets into the task, and can later actions still be traced to them?
T2Capability Integritywhether claims match the implementation; how faithfully capabilities are represented; whether the contract is honouredDo advertised capabilities match what is actually delivered?
T3Routing Authorizationauthority over the execution target; over the real audience; over routes and branchesWho gets a message, gets redirected, or steers the next step?
T4Content Authorityremote data turned into a trusted fact; into an action; kept and reused laterAt what point does remote data start controlling a local decision or action?
T5Object Validityvalidity over time; binding to the current contextIs a reused object still valid and tied to the current task?

The 13 subclasses, instantiated for A2A, ANP and BCS, give 39 protocol-specific specifications §3.3, §4.2. The protocol-native grounding of each class, with its objects and handoffs, is in tab. 6 app. B.

Pair construction

Each specification is embedded in a business scenario with a user objective, facts treated as trusted, assets to protect, and a result that can be verified §4.2. A task blueprint has three parts: the task semantics (goal, trusted facts, initial state); the collaboration plan (roles, candidate participants, communication paths, visibility, tools); and the evaluation contract (completion, the local risk event, downstream consequences, the attribution ground truth) §4.3. A protocol-native compiler maps the blueprint onto each protocol's discovery, messaging, task and state operations §4.3.

Both variants keep the same user objective, starting facts, candidate participants, role assignments, toolset and communication layout. Only the registered property differs §4.4, app. B. The domains are Healthcare, Finance, Logistics, Research and Travel, with five scenarios per domain and specification, giving 975 pairs §4.2. Construction used LLM-assisted drafting, structural checks, pair review and semantic review. Sampled human review was added §4.4.

Execution

  • Framework: OpenClaw. Each participant has an isolated runtime, a role description, its permitted materials and the collaboration history visible to its role §5.3.
  • Three models were tested, namely GPT-5.6 Terra, GLM-5.2 and MiniMax-M3. Every agent in a single run uses one shared model, and the two variants of a pair share that choice §5.2, §5.3.
  • Variants start from separate task-local state, so messages and artifacts from one run cannot feed the other §5.2.
  • Workflows: sequential, hybrid, star and fork/join, with 3 to 11 declared participants per task §5.2.
  • The orchestrator sets the permitted collaboration paths and visibility. The model chooses its own contribution and tool use inside those limits §5.3.
  • Agents may accept a remote result, check it, reject its claimed authority or take another course. A claimed action counts as an effect only when tool or task-state evidence supports it §5.3.
  • Native protocol paths: A2A finds peers through AgentCards and natively exchanges messages, tasks and artifacts. ANP resolves identities, reads service descriptions and calls endpoints after authentication, using its RemoteAgent mode for live collaboration. BCS runs a central service that tracks bots, sessions and message routing §5.3, §6.2.

Following influence through the task

Each influence is followed through six stages: entry (introduced through an allowed operation), reach (arrives at the evaluated boundary), consume (used by the recipient), propagate (passed to another agent or stage), decision (changes a choice or action) and effect (changes task state or the user's goal). An attack may stop at any stage §4.5.

Evidence for these stages comes from protocol logs, which show delivery and local state changes; from tool outputs and snapshots of the task state, which show actions and effects; and from a semantic Judge that reads the linked evidence for outcomes that need context, for example whether a claim was accepted as authority §4.5, §5.3. Expected outcomes and culprit identities are kept out of the agents' context §5.3.

Metrics

For each scheduled pair q, C is 1 when both variants complete, A is 1 when the malicious variant triggers its registered local event, and B is 1 when a verified downstream consequence follows from that event §5.5:

\mathrm{TCR}=\frac{\sum_{q}C_q}{|\mathcal{Q}|} eq. 2

\mathrm{ASR}=\frac{\sum_{q}C_qA_q}{\sum_{q}C_q} eq. 3

\mathrm{PTCR}=\frac{\sum_{q}C_qA_qB_q}{\sum_{q}C_qA_q} eq. 4

Audit-F1 is computed per locally successful harmful case. Precision and recall compare the predicted culprit set with the ground truth, and F1 = 2PR/(P+R). Case scores are then macro-averaged, and a case with no trace scores zero §5.5.

Pseudocode
# Per-pair flags: completed C, local event A, consequence B  [§5.5]
def summarise(pairs):
    # TCR is over all scheduled pairs  [§5.5] [eq. 2]
    completed = [p for p in pairs if p.both_variants_completed]
    tcr = len(completed) / len(pairs)
    # ASR is over completed pairs only  [§5.5] [eq. 3]
    local = [p for p in completed if p.malicious_local_event]
    asr = len(local) / len(completed)
    # PTCR is over locally successful pairs; N/A if none  [§5.5] [eq. 4]
    consequence = [p for p in local if p.verified_consequence]
    ptcr = len(consequence) / len(local) if local else None
    return tcr, asr, ptcr

Attribution: Native view versus Retained view

For each harmful execution, the same trace-only model localizer reads two views. The Native view has the records a protocol implementation exposes. The Retained view also records who was chosen, what was actually delivered, what an agent consumed, and what followed. The localizer uses a fixed prompt and output format, and ground-truth culprits are used only for scoring §5.4. A stratified human audit checks labels §5.4.

Protocol-Level Guard

The Guard adds checks at the discovery, routing, consumption and reuse points of each protocol. It evaluates the object's explicit identity, capability, routing and lifecycle evidence first. If that evidence does not settle the question, a limited semantic check by MiniMax-M3 asks whether the object's asserted authority suits the task. Possible outcomes are to permit the use, narrow its scope, ask for a fresh check, or refuse the object and fall back to a route that has been verified. Restrictions carry into later handoffs and are enforced at the tool and state control points. Rejections before local success are separated from containment after delivery §5.4.

The paper describes the Guard in prose only. The following is a paraphrase of that description and not the authors' algorithm. The paper gives no thresholds, no prompt and no rule that maps evidence to an outcome.

Pseudocode
# Protocol-Level Guard at one handoff  [§5.4]
# Paraphrase of the prose description; not an algorithm from the paper.
def guard_check(obj, proposed_use, context):
    # 1. Check identity, capability, routing and lifecycle evidence  [§5.4]
    evidence = protocol_evidence(obj, context)
    if evidence.resolved:
        outcome = evidence.outcome
    else:
        # 2. Bounded semantic review (MiniMax-M3) when evidence is open  [§5.4]
        outcome = bounded_review(obj, proposed_use, context)
    # 3. Allow, restrict, revalidate or reject; limits travel on  [§5.4]
    return outcome

Hyperparameters

This is an evaluation paper. It trains no model, so these are the experimental settings the paper states.

NameValueWhereNotes
Matched pairs975 (325 per protocol; 65 per protocol and domain)§5.2 tab. 239 specifications × 5 domains × 5 scenarios §4.2
ProtocolsA2A, ANP, BCS§3.3native paths in §5.3
DomainsHealthcare, Finance, Logistics, Research, Travel§4.2
ModelsGPT-5.6 Terra, GLM-5.2, MiniMax-M3§5.2 tab. 2one model shared by all agents in a run
Model-conditioned pair evaluations2,925tab. 2975 × 3
Execution instances5,850tab. 2benign and malicious variants
Participants per task3 to 11§5.2
Workflow shapessequential, hybrid, star, fork/join§5.2
Round and time limitstask-specific§5.2numeric values not stated
Guard evaluation setFinance, MiniMax-M3; 65 pairs per protocol, 195 total§5.4 tab. 4
Guard semantic review modelMiniMax-M3§5.4prompt and bounds not stated
Judge modelthe model condition of the run§5.3
Localizer model, prompt textnot stated (fixed prompt and output format)§5.4
Human audit sample sizenot stated§5.4
Repetitions, sampling settings, seeds, confidence intervalsnot stated
Protocol or OpenClaw version numbersnot stated

Results

Author-reported. The setup is the 975-pair suite under three model conditions §5.2, with the Guard comparison on the Finance subset with MiniMax-M3 §5.4.

RQ1: local success versus consequence

Main results, copied in full from the paper tab. 3. Each class averages its subclasses across the five domains. TCR is paired completion. ASR is local attack success among complete pairs. PTCR is downstream consequence among locally successful pairs. All values are percentages.

ProtocolRisk classMiniMax-M3 TCRASRPTCRGLM-5.2 TCRASRPTCRGPT-5.6 Terra TCRASRPTCR
A2AT1 Identity Binding99.598.586.499.7100.087.599.898.084.9
A2AT2 Capability Integrity99.897.882.1100.099.983.399.997.380.7
A2AT3 Routing Authorization99.297.573.899.699.875.099.596.972.5
A2AT4 Content Authority99.798.690.599.999.991.7100.098.188.9
A2AT5 Object Validity99.698.288.699.899.990.099.797.687.1
A2AAvg.99.698.184.399.899.985.599.897.682.8
ANPT1 Identity Binding100.078.060.0100.094.0100.0100.098.069.0
ANPT2 Capability Integrity100.0100.092.0100.0100.0100.0100.0100.098.3
ANPT3 Routing Authorization100.066.7100.0100.066.7100.0100.056.792.7
ANPT4 Content Authority100.092.019.4100.097.37.1100.089.112.6
ANPT5 Object Validity100.0100.042.6100.0100.0100.0100.0100.044.8
ANPAvg.100.087.362.8100.091.681.4100.088.863.5
BCST1 Identity Binding100.082.0100.0100.098.094.4100.078.080.6
BCST2 Capability Integrity100.098.7100.0100.0100.098.7100.091.386.8
BCST3 Routing Authorization100.066.7100.0100.066.7100.0100.048.3100.0
BCST4 Content Authority100.078.774.1100.0100.098.7100.093.647.5
BCST5 Object Validity100.048.093.2100.088.093.3100.050.095.3
BCSAvg.100.074.893.5100.090.597.0100.072.282.0

Headline findings §6.1:

  • TCR stays between 99.2% and 100.0% in every cell, so the analysis focuses on ASR and PTCR §6.1, tab. 3.
  • ASR is often at or above 90%, and the PTCR range runs from 7.1% (ANP-T4, GLM-5.2) to 100.0% §6.1, tab. 3.
  • Mean PTCR across risk classes, at comparably high ASR, is 76.1% for GPT-5.6 Terra, 80.2% for MiniMax-M3 and 87.9% for GLM-5.2 §6.1. Recomputing from the three Avg rows of tab. 3 gives 76.1, 80.2 and 88.0 (see Pitfalls).
  • ANP-T4 has ASR of 89.1 to 97.3% but PTCR of 7.1 to 19.4%. ANP-T3 and BCS-T3 have ASR of 48.3 to 66.7% but PTCR of 92.7 to 100.0% §6.1, tab. 3.

RQ2: attribution

Audit-F1, macro-averaged over three model conditions fig. 4, §6.2. Values below were read from the bar data in the paper's figure source, so they are close to the figure but not printed in the text. Averages were recomputed from them.

Protocol and viewT1T2T3T4T5Avg.
A2A, Native20.721.220.226.711.120.0
A2A, Retained100.0100.0100.0100.0100.0100.0
ANP, Native0.00.00.00.00.00.0
ANP, Retained91.783.3100.0100.094.393.9
BCS, Native11.186.780.084.582.969.0
BCS, Retained88.9100.0100.088.185.892.6

Across all 15 protocol and class cases, macro-averaged Audit-F1 rises from 29.7% (Native) to 95.5% (Retained) §6.2. The gain is largest for ANP, whose native records do not link a request and result to the consuming agent §6.2.

RQ3: Guard on Finance with MiniMax-M3

Copied in full from the paper tab. 4. Percentages. Guard rows show the Protocol-Level Guard. "N/A" means no local success remained.

ProtocolRisk classNo Guard TCRASRPTCRGuard TCRASRPTCR
A2AT199.790.182.395.340.135.6
A2AT298.093.580.996.746.820.9
A2AT399.990.746.894.070.710.1
A2AT499.396.386.798.733.016.7
A2AT5100.083.964.197.250.617.4
A2AAvg.99.490.972.296.448.220.1
ANPT1100.090.044.4100.078.742.6
ANPT2100.0100.090.096.766.780.0
ANPT3100.066.7100.097.333.3100.0
ANPT4100.0100.013.393.392.90.0
ANPT5100.0100.020.095.050.010.0
ANPAvg.100.091.353.596.564.346.5
BCST1100.080.0100.094.570.057.1
BCST2100.0100.0100.076.766.70.0
BCST3100.066.7100.096.40.0N/A
BCST4100.073.366.7100.069.340.0
BCST5100.060.016.795.038.211.1
BCSAvg.100.076.070.992.548.827.1

The headline Guard numbers in the abstract are the means of the three protocol Avg rows: ASR 86.1% to 53.8%, PTCR 65.5% to 31.2%, and TCR 99.8% to 95.1% §6.3, tab. 4. The paper reports that the Guard brought BCS-T3 ASR to 0.0%, which it reads as rejection before local success. ANP-T4 keeps 92.9% ASR, but its PTCR falls to 0.0%. A2A-T4 falls sharply on both ASR and PTCR §6.3, tab. 4.

Paper vs code

No official code.

What was searched (2026-11-21):

  • The arXiv abstract page lists no code, project or repository link. The paper's own text has no code or data URL. Its references link the A2A project and the Avernet BCS implementation (inclusionAI); these are protocol implementations, not this paper's evaluation code [reference.bib].
  • GitHub API search for "Agent-Canary-Mas": no results.
  • GitHub API search for "ProtoEcho" (a name in the figure and file labels of the TeX source): two unrelated user repositories.
  • GitHub API search for "PinchBench" (a working name in the TeX source's figure labels and a trace field name): 39 repositories by other owners, including the pinchbench organisation. None is linked from the paper and none is used here.
  • The inclusionAI organisation page lists Avernet but not this benchmark.

Because no official repository was found, nothing in this card is checked against code. The code may exist under a name not searched here.

Pitfalls

  • The Guard is prose only. Section 5.4 names the four outcomes (allow, restrict, revalidate, reject) but gives no algorithm, thresholds, prompt, or rule that maps evidence to an outcome. The TeX source defines a guard-prompt box, but no prompt text appears in the body. Anyone re-implementing it must design these choices, and the results depend on them.
  • The same model plays several roles. The Guard's bounded semantic review uses MiniMax-M3, which is also one of the three evaluated agent models. The Judge uses the model condition of each run §5.3, §5.4. The paper says these shared roles may correlate errors §7.
  • Localizer and Judge are underspecified. The localizer's model and prompt text are not stated, and the human audit sample size is not stated §5.4. Audit-F1 gives a zero score to a case with no trace §5.5, so a missing trace counts as a failure of attribution, not as missing data.
  • Small cells. Each subclass has 25 pairs per protocol and model before completion filtering. This is derived from the design: 5 domains × 5 scenarios §4.2. A class cell averages two or three subclasses tab. 5. One pair moves a subclass by 4 percentage points. The Guard comparison has only 5 pairs per subclass per protocol, all in Finance §5.4. The paper states no repetitions, sampling settings or confidence intervals, so differences of a few points should not be read as reliable.
  • PTCR's denominator moves. PTCR is conditioned on locally successful pairs. When the Guard stops more attacks, the denominator shrinks and the remaining cases can look worse or better §7. Read TCR beside ASR and PTCR. The identity ASR × PTCR gives the fraction of completed pairs with both a local success and a consequence, but only within a single cohort §5.5.
  • Native versus Retained is also an instrumentation comparison. The Retained view contains manifests, selection and routing evidence, and a cross-node trace that the authors built §6.2, app. D. The gap therefore measures how much evidence was recorded as well as what the protocol exposes. The ANP Native result of 0.0 also depends on the RemoteAgent mode the authors chose; they note that ANPInterface targets a different use §6.2.
  • Consequences are judged, not always observed. Context-dependent outcomes, such as a claim being accepted as authority, come from a semantic Judge. A claimed action counts only when tool or task-state evidence supports it §5.3. Expected outcomes are hidden from the agents.
  • Text-to-table mismatches. (a) §6.1 calls routing (T3) the lowest-ASR class for ANP and BCS, at 48.3 to 66.7%. Under MiniMax-M3, BCS-T5 is 48.0%, lower than BCS-T3 at 66.7% tab. 3. (b) The text gives GLM-5.2's mean PTCR as 87.9%. The three Avg rows of tab. 3 give 88.0% (87.97 before rounding), so the paper probably averaged unrounded values. Use the table values for reimplementation checks.
  • Scope and cost. Findings apply only to the tested protocol implementations, configurations, policies and execution path §7. Excluded threats include collusion and credential compromise §3.2. Latency, token cost and throughput are not measured, so the Guard's overhead is unknown §7. The Guard's completion cost is an average TCR drop of about 4.7 points, from 99.8% to 95.1%, and BCS-T2 falls to 76.7% §7, tab. 4.
  • Model comparisons are not a safety ranking. Models were compared inside one OpenClaw setup with fixed roles, tools and protocol integrations. The paper says the results should not be read as an intrinsic safety ranking §7.
  • Round and time limits are task-specific and not given as numbers §5.2. Implementers should expect different turn budgets to change results.
  • Implementation pinning. No protocol, OpenClaw or model-API version is stated in the body text, so a faithful rerun cannot be pinned from the paper alone.

Lineage

  • Builds on: the A2A, ANP and BCS protocols, as published by their maintainers (the paper's references cite a2aproject2026, DBLP:journals/corr/abs-2508-00007 and avernet2026). The OpenClaw runtime is used as the agent framework §5.3.
  • Compared against: AgentDojo, InjecAgent, ConVerse, ACIArena, A2ASecBench, AIP-Bench and ProtocolBench, named in §1. The paper states that NVIDIA NeMo Guardrails was found to give limited protection against MAS-specific attacks in A2ASecBench §6.3.
  • Superseded by: not stated.

Source and license

Adapted from “Agent-Canary-Mas: End-to-End Evaluation of Protocol Risk in Long-Horizon Multi-Agent Systems” by Xiuming Liu, Le Gai, Zhiyuan Chang, Peiyang Li, Bin Zhu, Shuo Wang, Chao Feng (arXiv:2610.15529), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.