LLM agent communication protocols: a technical taxonomy¶
Scope: how independently built LLM agents address, exchange, and discover each other. This page is a structured reading of "A Technical Taxonomy of LLM Agent Communication Protocols" (arXiv 2606.19135), which classifies nine actively maintained open-source protocols along five dimensions and predicts where the fragmented landscape is heading. It sits above the single-protocol view of tool calling in tools and function calling (the Model Context Protocol is one of the nine), complements the role-team communication pattern in multi-agent collaboration, and feeds the scheduling and routing concerns of the orchestration and control plane. The interoperability model below is an operationalization of the taxonomy, not a claim from the paper.
Protocol names and dimension values are transcribed from the paper (abstract, dimension definitions in Section 5.2, and the Table 2 classification). Protocols in this space move fast and versions drift, so re-verify a protocol's current design against its own spec before relying on a cell in the table. Two cells to re-check specifically: the discovery column (below) and ANP, whose own materials describe it as peer-to-peer while the paper's table records its discovery as centralized. The Python interoperability model is executed and asserted (pure stdlib).
flowchart TB
META["Meta-characteristic:<br/>components involved + communication traits"] --> DIMS
subgraph DIMS["Five dimensions"]
D1["Counterparty<br/>agent / context / hybrid"]
D2["Payload<br/>structured / conversation / hybrid"]
D3["Interaction state<br/>stateless / session"]
D4["Discovery<br/>static / centralized / partial / decentralized / hybrid"]
D5["Schema flexibility<br/>single / multiple / evolving"]
end
DIMS --> CLS["Classify nine protocols"]
CLS --> CTX["Context-facing:<br/>MCP, agents.json"]
CLS --> AG["Agent-to-agent:<br/>A2A, LAP, Agora, ANP, LMOS, ACP, agntcy"]What it is¶
The paper builds a technical taxonomy to classify and compare LLM agent communication protocols, the wire-level agreements that let agents built by different teams talk to each other, to tools, and to data sources.1 It is constructed with Nickerson et al.'s established iterative method: the authors first fix the taxonomy's purpose, a meta-characteristic ("classifying the protocols according to the types of components involved and the characteristics of their communication"), and ending conditions, then run five iterations, three empirical-to-conceptual followed by two conceptual-to-empirical, over a curated sample of protocols.2 The objective ending condition is that no new dimension emerges and every characteristic is instantiated; the subjective condition is that the result stay concise, robust, comprehensive, extensible, and explanatory.2
The sample is nine actively maintained open-source protocols with demonstrable adoption:3
- Model Context Protocol (MCP), a standard for augmenting an LLM with tools and contextual data from applications and APIs.
- Agent to Agent (A2A), agent-to-agent connectivity across diverse frameworks and platforms with a secure, extensible design.
- LangChain Agent Protocol (LAP), a RESTful API with unified endpoints for deploying and managing agents in production.
- agents.json, a JSON specification that lets agents discover and interpret existing websites and APIs.
- Agora, a decentralized protocol for agent collaboration without central servers or predefined schemas.
- Agent Network Protocol (ANP), a peer-to-peer protocol for secure, decentralized collaboration across the internet.
- LMOS, an Eclipse-ecosystem protocol letting agents and tools publish, connect, and share capabilities across transport layers.
- Agent Communication Protocol (ACP), a RESTful open standard for structured communication and discovery among heterogeneous agents.
- agntcy, infrastructure for an Internet of Agents whose Agent Connect Protocol extends OpenAPI for interoperability.
The taxonomy comprises five dimensions: counterparty, payload, interaction state, discovery mechanism, and schema flexibility.1 Every protocol reduces to one value on each, so the whole sample fits in a nine-by-five table (reproduced under the protocol landscape).
Why it matters¶
Multi-agent systems exist to overcome the limits of a standalone agent, which makes the communication layer core infrastructure rather than an afterthought. The paper's framing is that the landscape is fragmented, and fragmentation is an interoperability problem: two agents that cannot agree on how to address, encode, and discover each other cannot collaborate at all.1 A taxonomy turns "there are too many protocols" into a set of orthogonal questions a platform team can actually answer: does this protocol talk to agents or to tools, does it keep a session, how does one agent find another, and can the message schema change at runtime.
For a cluster or platform operator the practical payoff is protocol selection. The five dimensions are the axes on which a wrong choice hurts: pick a stateless tool protocol for a long multi-turn deliberation and you carry session state yourself; pick a static-discovery protocol for a fleet that scales elastically and you hand-maintain endpoint lists; pick a single-schema protocol and every counterparty must speak exactly that schema. The taxonomy also names the gaps the current generation leaves open, notably privacy and policy enforcement, which are not first-class in any of the nine.1
The five dimensions¶
Each dimension is a small closed set of values.45
- Counterparty is who a protocol is designed to talk to. Values: agent (agent-to-agent peers), context (tools and data sources, the augment-the-model direction), or hybrid (both). MCP and agents.json are context-facing; most of the rest are agent-facing; LMOS is hybrid.
- Payload is what a message carries. Values: structured data and artifacts (typed request and response objects), conversation focused (natural-language turns), or hybrid (both). The context protocols carry structured artifacts; the agent protocols carry hybrid payloads.
- Interaction state is whether the protocol remembers a conversation. Values: stateless (each message is independent) or session state (a stateful unit of work persists across message exchanges). Session state is the substrate that multi-turn work needs, which links directly to agent context and memory.
- Discovery mechanism is how one endpoint finds another. Values, quoted from the paper: static ("requesting agent must know the endpoint a priori"), centralized ("registry maintains a list of accessible endpoints"), partially centralized ("limited set of supernodes assists with discovery"), decentralized ("no central authority exists and each peer maintains its own index, with discovery occurring via network broadcasting"), and hybrid ("protocols that support multiple discovery mechanisms beyond static configuration").5
- Schema flexibility is whether the message schema can change. Values: single (one fixed schema), multiple (a set of predefined schemas to choose from), or evolving (schemas negotiated at runtime). Only two protocols reach evolving.
The protocol landscape¶
The paper's Table 2 classification, transcribed. Read each row as one protocol's coordinate in the five-dimensional space; identical rows (ACP and agntcy) are the trivially interoperable case, and rows that differ on a single dimension are the ones a bridge can most cheaply reconcile.
| Protocol | Counterparty | Payload | Interaction state | Discovery | Schema |
|---|---|---|---|---|---|
| MCP | context | structured + artifacts | stateless | static | multiple |
| A2A | agent | hybrid | session | centralized | multiple |
| LAP | agent | hybrid | session | static | single |
| agents.json | context | structured + artifacts | stateless | static | single |
| Agora | agent | hybrid | session | static | evolving |
| ANP | agent | hybrid | session | centralized | evolving |
| LMOS | hybrid | hybrid | session | hybrid | multiple |
| ACP | agent | hybrid | session | centralized | multiple |
| agntcy | agent | hybrid | session | centralized | multiple |
The paper does not expect one of these rows to win. Its prediction is a federated, layered protocol stack: no single protocol will maximize versatility, efficiency, and portability at once, so the Internet of Agents will likely use lightweight specifications such as agents.json for static capability discovery, defer to structured context protocols such as MCP for secure tool execution, and reserve session-aware, schema-evolving protocols such as ANP or Agora for complex multi-turn deliberation.7 Short term, the authors see convergence pressure toward protocols that unify agent-to-agent and agent-to-context communication; long term, the layered split.7
flowchart TB
subgraph STACK["Predicted federated, layered stack (authors' analysis)"]
L1["Discovery layer<br/>lightweight capability specs, e.g. agents.json"]
L2["Context/tool layer<br/>structured execution, e.g. MCP"]
L3["Deliberation layer<br/>session-aware, schema-evolving, e.g. ANP / Agora"]
end
L1 --> L2 --> L3
L3 -->|"open gaps"| GAP["Privacy and policy enforcement<br/>not first-class in any of the nine"]An executable interoperability model¶
The taxonomy is a classifier, so it can be executed. The model below encodes each protocol as its Table 2 vector and defines an interoperability predicate: two protocols interoperate without a translation bridge only when every dimension is compatible. The compatibility rule and the predicate are an operationalization, not the paper's; the paper defines the taxonomy, not a formal interoperability function. The one design choice worth stating is supertype subsumption: a hybrid counterparty, a hybrid payload, a hybrid discovery mode, a session-capable state, and an evolving (runtime-negotiating) schema each subsume the narrower values, because such an endpoint can also speak the narrower dialect. The asserts reproduce four things: the boundary case, the discovery-gap failure, the schema-flexibility advantage, and the paper's empirical findings.
# protocol_interop.py -- validated: an operationalization of the paper's taxonomy
# (arXiv 2606.19135, Table 2) as an executable classifier plus an interoperability
# predicate. Each of the nine protocols is a vector over the five dimensions; the
# predicate decides whether two protocols can exchange messages WITHOUT a bridge.
# The compatibility rule and the interoperability predicate are OUR model, not the
# paper's (the paper defines the taxonomy, not a formal interop function). Pure stdlib.
#
# Value shorthands map to the paper's characteristics:
# payload "structured" = "structured data and artifacts"; "session" = "session state".
# Supertype subsumption rule (our operationalization): a "hybrid" counterparty/
# payload/discovery and a "session" interaction-state and an "evolving" schema are
# SUPERTYPES that subsume the narrower values, since a hybrid/session/negotiating
# endpoint can also speak the narrower dialect.
DIMS = ("counterparty", "payload", "interaction_state", "discovery", "schema")
# Paper's Table 2 classification, transcribed. (counterparty, payload, state, discovery, schema)
PROTOCOLS: dict[str, tuple[str, str, str, str, str]] = {
"MCP": ("context", "structured", "stateless", "static", "multiple"),
"A2A": ("agent", "hybrid", "session", "centralized", "multiple"),
"LAP": ("agent", "hybrid", "session", "static", "single"),
"agents.json": ("context", "structured", "stateless", "static", "single"),
"Agora": ("agent", "hybrid", "session", "static", "evolving"),
"ANP": ("agent", "hybrid", "session", "centralized", "evolving"),
"LMOS": ("hybrid", "hybrid", "session", "hybrid", "multiple"),
"ACP": ("agent", "hybrid", "session", "centralized", "multiple"),
"agntcy": ("agent", "hybrid", "session", "centralized", "multiple"),
}
SUPERTYPE = {"counterparty": "hybrid", "payload": "hybrid",
"interaction_state": "session", "discovery": "hybrid"}
def dim_compat(dim: str, a: str, b: str) -> bool:
"""Per-dimension compatibility with supertype subsumption."""
if a == b:
return True
if dim == "schema":
return "evolving" in (a, b) # a runtime-negotiating side adapts to any counterpart
return SUPERTYPE.get(dim) in (a, b) # hybrid/session subsumes the narrower value
def incompatible_dims(p: str, q: str) -> set[str]:
va, vb = PROTOCOLS[p], PROTOCOLS[q]
return {d for d, a, b in zip(DIMS, va, vb) if not dim_compat(d, a, b)}
def interoperable(p: str, q: str) -> bool:
"""Two protocols interoperate WITHOUT a bridge iff every dimension is compatible."""
return not incompatible_dims(p, q)
# ---- (d) BOUNDARY: identical dimension vectors are trivially interoperable ----
# ACP and agntcy have identical vectors in Table 2 -- a real in-sample boundary case.
assert PROTOCOLS["ACP"] == PROTOCOLS["agntcy"]
assert interoperable("ACP", "agntcy") and incompatible_dims("ACP", "agntcy") == set()
assert all(interoperable(p, p) for p in PROTOCOLS) # reflexive
# ---- (a) payload-agree but discovery-differ => NOT interoperable without a bridge ----
# A2A and Agora both carry hybrid payloads, agree on counterparty/state/schema-compat,
# and differ ONLY on discovery (centralized vs static); that lone gap blocks them.
assert PROTOCOLS["A2A"][1] == PROTOCOLS["Agora"][1] == "hybrid" # payload agrees
assert incompatible_dims("A2A", "Agora") == {"discovery"} # the ONLY blocker
assert not interoperable("A2A", "Agora") # bridge required
# Counterfactual: give Agora centralized discovery and the pair interoperates.
Agora_c = ("agent", "hybrid", "session", "centralized", "evolving")
assert all(dim_compat(d, a, b) for d, a, b in zip(DIMS, PROTOCOLS["A2A"], Agora_c))
# ---- (b) schema-flexible (evolving) protocols interoperate with MORE counterparts ----
# Controlled experiment: hold four dimensions fixed, vary only schema flexibility.
BASE = ("agent", "hybrid", "session", "centralized")
single_vec = BASE + ("single",)
evolving_vec = BASE + ("evolving",)
def partners(vec: tuple[str, ...]) -> set[str]:
return {n for n, v in PROTOCOLS.items()
if not {d for d, a, b in zip(DIMS, vec, v) if not dim_compat(d, a, b)}}
single_partners, evolving_partners = partners(single_vec), partners(evolving_vec)
assert single_partners <= evolving_partners # evolving never loses a counterpart
assert len(evolving_partners) > len(single_partners) # and strictly gains some
# The gain is exactly the fixed-schema neighbours a single-schema side cannot match:
assert (evolving_partners - single_partners) == {"A2A", "LMOS", "ACP", "agntcy"}
# ---- (c) reproduce the paper's empirical findings as assertions over the sample ----
def col(i: int) -> list[str]:
return [v[i] for v in PROTOCOLS.values()]
# Agent-to-agent = any protocol not purely context-facing (counterparty agent or hybrid).
a2a_set = {n for n, v in PROTOCOLS.items() if v[0] in ("agent", "hybrid")}
assert a2a_set == {"A2A", "LAP", "Agora", "ANP", "LMOS", "ACP", "agntcy"} # 7 of 9
# Finding: ALL agent-to-agent protocols combine hybrid payload with session state.
assert all(PROTOCOLS[n][1] == "hybrid" and PROTOCOLS[n][2] == "session" for n in a2a_set)
# The two context-only protocols are exactly MCP and agents.json (stateless + structured).
context_only = {n for n, v in PROTOCOLS.items() if v[0] == "context"}
assert context_only == {"MCP", "agents.json"}
assert all(PROTOCOLS[n][2] == "stateless" and PROTOCOLS[n][1] == "structured"
for n in context_only)
# Finding: most protocols support more than a single schema (7 of 9); exactly two
# negotiate at runtime (evolving = Agora, ANP).
assert sum(s in ("multiple", "evolving") for s in col(4)) == 7
assert {n for n, v in PROTOCOLS.items() if v[4] == "evolving"} == {"Agora", "ANP"}
# Finding: decentralized discovery is rare. No sampled protocol is PURELY decentralized;
# the peer-to-peer mode appears only inside LMOS's hybrid discovery (1 of 9).
assert col(3).count("decentralized") == 0
assert {n for n, v in PROTOCOLS.items() if v[3] == "hybrid"} == {"LMOS"}
assert sum(d in ("decentralized", "hybrid") for d in col(3)) == 1
# ---- Fragmentation summary over the whole sample (illustrative, not a paper claim) ----
names = list(PROTOCOLS)
pairs = [(names[i], names[j]) for i in range(len(names)) for j in range(i + 1, len(names))]
interop = [(p, q) for p, q in pairs if interoperable(p, q)]
bridge = len(pairs) - len(interop)
print(f"protocols={len(PROTOCOLS)} agent-to-agent={len(a2a_set)} context-only={len(context_only)}")
print(f"schema: single={col(4).count('single')} multiple={col(4).count('multiple')} "
f"evolving={col(4).count('evolving')} (>=multiple = {sum(s!='single' for s in col(4))} of 9)")
print(f"discovery: static={col(3).count('static')} centralized={col(3).count('centralized')} "
f"hybrid(incl. peer-to-peer)={col(3).count('hybrid')} pure-decentralized={col(3).count('decentralized')}")
print(f"controlled schema test: single-schema reaches {len(single_partners)} partners, "
f"evolving reaches {len(evolving_partners)} (+{sorted(evolving_partners - single_partners)})")
print(f"sample interoperability graph: {len(interop)}/{len(pairs)} protocol pairs interoperate "
f"without a bridge; {bridge} pairs need one")
print("all assertions passed")
Run output:
protocols=9 agent-to-agent=7 context-only=2
schema: single=2 multiple=5 evolving=2 (>=multiple = 7 of 9)
discovery: static=4 centralized=4 hybrid(incl. peer-to-peer)=1 pure-decentralized=0
controlled schema test: single-schema reaches 1 partners, evolving reaches 5 (+['A2A', 'ACP', 'LMOS', 'agntcy'])
sample interoperability graph: 13/36 protocol pairs interoperate without a bridge; 23 pairs need one
all assertions passed
The 13-of-36 figure is the fragmentation thesis made concrete under this model: even inside a curated nine-protocol sample, most pairs cannot exchange messages without a bridge, and the single largest cause is a mismatched discovery mechanism. The controlled schema test isolates the paper's schema-flexibility trend: holding the other four dimensions fixed, a runtime-negotiating schema reaches every fixed-schema neighbour a single-schema endpoint cannot.
How to choose a protocol¶
The taxonomy is a selection checklist. Walk the five dimensions in order of how expensive a wrong answer is to reverse.
- Counterparty first. If the job is augmenting one model with tools and data, the context-facing protocols (MCP, agents.json) are the category; MCP is the structured tool-execution standard covered in tools and function calling. If the job is peers coordinating, you are in the agent-to-agent column and MCP alone will not carry it.
- Interaction state to match the work. Long, multi-turn deliberation needs session state; a stateless request-reply tool call does not, and paying for session machinery you never use is waste. The seven agent-to-agent protocols all keep session state; the two context protocols are stateless.
- Discovery to match the fleet. A fixed, known set of endpoints tolerates static discovery; an elastic fleet wants a registry (centralized) or, rarely, peer-to-peer (only LMOS offers a hybrid mode that includes it). Discovery is the dimension the executed model shows is most likely to block interoperability, so treat a discovery mismatch as a design decision, not an accident.
- Schema flexibility for change tolerance. If counterparties and message shapes are stable, a single or multiple predefined schema is simpler and safer; if they are heterogeneous and evolving, a runtime-negotiating protocol (Agora or ANP) buys reach at the cost of complexity.
- Expect to run more than one. The paper's own prediction is a layered stack, so the realistic answer is often "agents.json for discovery plus MCP for tools plus a session protocol for deliberation," bridged where dimensions clash, rather than a single winner. Where those bridges and routes live is an orchestration and control plane concern.
Findings and open questions¶
The empirical findings, stated by the authors over the nine-protocol sample and reproduced as assertions in the model above:6
- Agent-to-agent protocols share a shape. All sampled agent-to-agent protocols combine hybrid payloads with session-state persistence. The two exceptions to hybrid payloads, MCP and agents.json, are exactly the context-facing protocols.
- Schema flexibility is trending up. Most protocols support more than a single schema (seven of nine support multiple or evolving), and two negotiate schemas at runtime (Agora and ANP), which the authors read as movement toward schema flexibility. Note the wording gap: the abstract says "most protocols support multiple predefined schemas, and two negotiate schemas at runtime," while the body counts "the majority of protocols permit multiple schema definitions (7 of 9)"; both reconcile if seven of nine allow more than one schema and two of those seven negotiate at runtime.
- Decentralized discovery is rare. No sampled protocol is classified as purely decentralized; the peer-to-peer mode appears only inside LMOS's hybrid discovery.
The forward-looking claims are the authors' analysis, not measurements: short-term convergence pressure toward protocols that unify agent-to-agent and agent-to-context communication, and long-term evolution toward a federated, layered protocol stack because no single protocol will maximize versatility, efficiency, and portability at once.7 The named open research gaps are privacy and policy enforcement, neither of which is first-class in any of the nine.1
Two honest caveats about the classification itself. First, the taxonomy defines "decentralized" and "partially centralized" discovery characteristics, yet the sampled protocols instantiate them only through LMOS's hybrid mode rather than as a pure classification, which sits in mild tension with the stated objective ending condition that every characteristic be instantiated; the reconciliation was not fully derivable from the sections read here, so treat the discovery column as the cell most worth verifying against the paper. Second, the paper contradicts itself on ANP: its own protocol-description prose, citing ANP's materials, calls it "a peer-to-peer... protocol designed to enable secure, decentralized collaboration," four pages before Table 2 classifies its discovery mechanism as centralized, and the paper never reconciles the two. Checking ANP's own technical discovery specification (as opposed to its marketing language) resolves this in the table's favor: ANP-08 defines discovery via a well-known URI lookup and registration with search-service agents, neither of which matches the paper's own definition of decentralized (no central authority, peer-maintained indexes, network broadcasting); the "peer-to-peer" language in ANP's materials describes its DID-based identity layer, not its discovery mechanism as this taxonomy defines that dimension.
Failure modes¶
Interoperability pitfalls, several of which the executed model makes concrete.
- Discovery mismatch masquerading as compatibility. Two protocols can agree on payload, counterparty, state, and schema and still fail to connect because one expects a registry and the other a hard-coded endpoint. The model flags this as the single most common blocker in the sample, and it is easy to miss because the messages themselves would parse.
- Assuming a shared payload means a shared protocol. Hybrid payload is common across the agent-to-agent protocols, which invites the assumption that they interoperate; they do not, unless discovery and schema also line up. Shared payload is necessary, not sufficient.
- Single-schema lock-in. A single-schema protocol interoperates only with counterparties that speak exactly its schema. In the controlled test a single-schema endpoint reached one in-sample partner where an otherwise identical evolving endpoint reached five. Choosing single schema is choosing a smaller reachable set.
- Stateless-for-stateful and stateful-for-stateless. Running a multi-turn deliberation over a stateless tool protocol pushes session management into application code; running simple tool calls over a session protocol pays for machinery that is never used. The interaction-state dimension exists to make this an explicit choice.
- Betting on one universal protocol. The paper's analysis argues no single protocol dominates on versatility, efficiency, and portability together, so a design that assumes one will and hard-wires it is betting against the predicted layered stack. Bridges between layers are the expected steady state, not a temporary hack.
- Ignoring the unmodeled dimensions. The taxonomy does not make privacy or policy enforcement first-class, so a protocol chosen purely on these five dimensions can still be wrong on authorization, auditability, or data handling. Those belong to the governance layer around the protocol, not the protocol row.
References¶
- Sander, Gidey, Lenz, Knoll, "A Technical Taxonomy of LLM Agent Communication Protocols" (arXiv 2606.19135, submitted 2026-06-17): https://arxiv.org/abs/2606.19135
- Model Context Protocol (one of the nine, context-facing): https://modelcontextprotocol.io/
- Agent2Agent (A2A) Protocol (one of the nine, agent-facing): https://a2a-protocol.org/
- Nickerson, Varshney, Muntermann, "A method for taxonomy development and its application in information systems," European Journal of Information Systems 22(3), 2013 (the iterative taxonomy method the paper follows): https://doi.org/10.1057/ejis.2012.26
Related: Tools and function calling · Multi-agent collaboration · Orchestration and control plane · Agent context and memory · Agentic systems · Glossary
-
arXiv 2606.19135, Abstract. Robust communication protocols are "essential infrastructure for distributed agent networks"; the "fragmented protocol landscape presents a significant interoperability challenge." Five dimensions: counterparty, payload, interaction state, discovery mechanism, schema flexibility. Findings quoted: "all sampled agent-to-agent protocols combine hybrid payloads with session-state persistence; most protocols support multiple predefined schemas, and two negotiate schemas at runtime, indicating a trend toward schema flexibility; decentralized discovery remains rare." Open gaps: "privacy and policy enforcement." ↩↩↩↩↩
-
arXiv 2606.19135, taxonomy-development method. Nickerson et al.'s iterative approach: define purpose, meta-characteristic, and ending conditions, then five iterations (three empirical-to-conceptual, two conceptual-to-empirical). Meta-characteristic: "classifying the protocols according to the types of components involved and the characteristics of their communication." Objective ending condition: "no new dimensions emerge and every characteristic is instantiated." Subjective conditions: concise, robust, comprehensive, extensible, explanatory. ↩↩
-
arXiv 2606.19135, protocol descriptions (nine actively maintained open-source protocols with demonstrable adoption): MCP (augment LLMs with tools and contextual information); A2A (agent-to-agent connectivity across frameworks and platforms); LangChain Agent Protocol / LAP (RESTful API with unified endpoints for deploying and managing agents); agents.json (JSON spec for agents to discover and interpret websites and APIs); Agora (decentralized collaboration without central servers or predefined schemas); Agent Network Protocol / ANP (peer-to-peer, secure, decentralized collaboration across the internet); LMOS (Eclipse ecosystem; publish, connect, and share capabilities across transport layers); Agent Communication Protocol / ACP (RESTful open standard for structured communication and discovery among heterogeneous agents); agntcy (Internet of Agents infrastructure; Agent Connect Protocol extending OpenAPI). ↩
-
arXiv 2606.19135, dimension characteristics (Table 2 and dimension definitions). Counterparty: agent, context, hybrid. Payload: structured data and artifacts, conversation focused, hybrid. Interaction state: stateless, session state. Discovery mechanism: static, centralized, partially centralized, decentralized, hybrid. Schema flexibility: single, multiple, evolving. ↩
-
arXiv 2606.19135, Section 5.2 (discovery mechanism). Static: "requesting agent must know the endpoint a priori." Centralized: "registry maintains a list of accessible endpoints." Partially centralized: "limited set of supernodes assists with discovery." Decentralized: "no central authority exists and each peer maintains its own index, with discovery occurring via network broadcasting." Hybrid: "protocols that support multiple discovery mechanisms beyond static configuration." In the sample, only LMOS carries a hybrid discovery mode incorporating peer-to-peer; no protocol is classified as purely decentralized. The paper's stated Table 2 assignments used here: MCP static; A2A, ANP, ACP, agntcy centralized; LAP, agents.json, Agora static; LMOS hybrid. ANP is described elsewhere as peer-to-peer; verify its discovery cell against the source. ↩↩
-
arXiv 2606.19135, classification results. "All remaining protocols are classified as hybrid" payload (all agent-to-agent protocols, i.e. all except the context-facing MCP and agents.json). "All protocols designed for agent-to-agent communication support multi-turn interactions through stateful units of work persisting across message exchanges." Schema: "the majority of protocols permit multiple schema definitions (7 of 9)"; the two evolving (runtime-negotiating) protocols are Agora ("Protocol Document, a plain-text description ... actively constructed and negotiated at runtime") and ANP ("similarly supports dynamic negotiation of payload formats and interaction structures"). Discovery: "only the LMOS protocol truly incorporates a decentralized, peer-to-peer approach," within its hybrid discovery modes. ↩
-
arXiv 2606.19135, analysis and conclusion (authors' forward-looking claims, not measurements). Short term: convergence pressure "toward protocols unifying agent-to-agent and agent-to-context (tool and data) communication." Long term: "no single protocol is likely to maximize versatility, efficiency, and portability simultaneously," and "the field will more likely evolve toward a federated, layered protocol stack" using "lightweight specifications, such as agents.json, for static capability discovery; ... highly structured context-protocols, e.g., MCP, for secure tool execution; and ... session-aware, schema-evolving protocols, e.g., ANP or Agora, for complex, multi-turn deliberations." ↩↩↩