arxiv: 2604.09744 · v1 · submitted 2026-04-10 · 💻 cs.MA · cs.AI

Recognition: 1 theorem link

· Lean Theorem

MPAC: A Multi-Principal Agent Coordination Protocol for Interoperable Multi-Agent Collaboration

Kaiyang Qian, Xinmin Fang, Zhengxiong Li

Authors on Pith no claims yet

Pith reviewed 2026-05-10 17:32 UTC · model grok-4.3

classification 💻 cs.MA cs.AI

keywords multi-principal agent coordinationAI agent interoperabilityshared state protocolsconflict managementintent-based operationsgovernance layersmulti-agent systems

0 comments

The pith

MPAC supplies an application-layer protocol with five layers for agents owned by separate principals to coordinate over shared state.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Existing agent protocols assume a single owner for all agents, so tasks involving independent principals such as joint code editing or cross-organization decisions fall back to ad-hoc chat or manual merges. The paper defines MPAC to address this by requiring intent declarations before operations, representing conflicts as explicit objects, and providing a pluggable governance layer for arbitration. It specifies 21 message types, state machines, Lamport-clock watermarks, and optimistic concurrency control to make coordination deterministic across principals. A three-agent code review test shows the approach reduces coordination overhead by 95 percent and delivers 4.8 times faster wall-clock completion than serialized human mediation, while keeping per-agent decision times unchanged. The speedup arises from removing waiting periods rather than from faster model inference.

Core claim

MPAC is an application-layer protocol that equips agents belonging to independent principals with explicit coordination semantics through the Session, Intent, Operation, Conflict, and Governance layers, together with 21 message types, three normative state machines, Lamport-clock causal ordering, two execution models, three security profiles, and optimistic concurrency on shared state; the protocol is realized in open-source Python and TypeScript reference implementations that pass 223 tests and demonstrate measurable efficiency gains in a controlled multi-agent benchmark.

What carries the argument

The five-layer stack (Session for connection lifecycle, Intent as a precondition for action, Operation on shared state, Conflict as a first-class structured object, and Governance for pluggable arbitration) enforced by state-machine transition tables and optimistic concurrency control.

If this is right

Intent must be declared before any operation on shared state, preventing silent overwrites.
Conflicts appear as structured objects that downstream components can inspect and resolve programmatically or via human review.
The governance layer can be swapped for different arbitration policies without changing the core coordination logic.
Lamport-clock watermarks establish causal order across agents without a central clock.
Two execution models and three security profiles allow the same protocol to cover both low-latency and high-assurance deployments.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

If widely implemented, the protocol could let separate organizations run their own specialized agents that negotiate joint decisions without merging codebases or sharing full control.
The same intent-conflict-governance pattern might apply to other shared-resource domains such as family trip planning or multi-party resource allocation.
Optimistic concurrency combined with explicit conflicts could lower latency in real-time settings where agents must act before full consensus is reached.

Load-bearing premise

The defined message formats, state machines, and optimistic concurrency rules will continue to function correctly when applied to agents and tasks outside the three-agent code-review benchmark and that independent principals will actually adopt the protocol in practice.

What would settle it

An independent replication of the three-agent code-review benchmark using different agent back-ends, or a live deployment in which agents controlled by separate organizations attempt to edit a shared repository using only the MPAC message formats without additional custom code.

Figures

Figures reproduced from arXiv: 2604.09744 by Kaiyang Qian, Xinmin Fang, Zhengxiong Li.

read the original abstract

The AI agent ecosystem has converged on two protocols: the Model Context Protocol (MCP) for tool invocation and Agent-to-Agent (A2A) for single-principal task delegation. Both assume a single controlling principal, meaning one person or organization that owns every agent. When independent principals' agents must coordinate over shared state, such as engineers' coding agents editing the same repository, family members planning a shared trip, or agents from different organizations negotiating a joint decision, neither protocol applies, and coordination collapses to ad-hoc chat, manual merging, or silent overwrites. We present MPAC (Multi-Principal Agent Coordination Protocol), an application-layer protocol that fills this gap with explicit coordination semantics across five layers: Session, Intent, Operation, Conflict, and Governance. MPAC makes intent declaration a precondition for action, represents conflicts as first-class structured objects, and supports human-in-the-loop arbitration through a pluggable governance layer. The specification defines 21 message types, three state machines with normative transition tables, Lamport-clock causal watermarking, two execution models, three security profiles, and optimistic concurrency control on shared state. We release two interoperable reference implementations in Python and TypeScript with 223 tests, a JSON Schema suite, and seven live multi-agent demos. A controlled three-agent code review benchmark shows a 95 percent reduction in coordination overhead and a 4.8 times wall-clock speedup versus a serialized human-mediated baseline, with per-agent decision time preserved. The speedup comes from eliminating coordination waits, not compressing model calls. Specification, implementations, and demos are open source.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

MPAC provides a practical, well-implemented protocol for multi-principal agent coordination with open code and benchmark evidence.

read the letter

MPAC fills a real gap in multi-agent systems by providing a protocol for agents belonging to independent principals to coordinate on shared state. The authors specify five layers—Session, Intent, Operation, Conflict, and Governance—along with 21 message types, state machines, Lamport-clock watermarking, and optimistic concurrency control. They release open implementations in Python and TypeScript, complete with 223 tests, JSON Schema, and live demos. The paper does well by grounding the claims in runnable code and a controlled benchmark. The three-agent code review experiment shows substantial gains: 95% less coordination overhead and 4.8 times speedup over a serialized human baseline, without changing per-agent decision times. This comes from parallel execution enabled by the protocol rather than any model optimization. Soft spots are minor. The benchmark results are presented at a summary level, which makes it harder to assess without the supplementary materials or code. Generalization beyond the code review task is plausible given the design but not yet demonstrated in other domains like collaborative planning. The assumption that independent parties will adopt the specific message formats and governance layer is reasonable but untested at scale. This paper is for anyone building or studying interoperable multi-agent applications, particularly in software engineering or decision-making workflows. It shows honest engagement with the problem through its formal specs and empirical checks. I recommend sending it for peer review. The implementations and tests make it worth a referee's time even if revisions are needed on the evaluation details.

Referee Report

0 major / 2 minor

Summary. The paper introduces MPAC, an application-layer protocol for coordinating agents owned by independent principals over shared state (e.g., joint code editing or trip planning). It specifies five layers (Session, Intent, Operation, Conflict, Governance), 21 message types, three normative state machines, Lamport-clock watermarking, optimistic concurrency control, two execution models, and three security profiles. The authors release two interoperable reference implementations (Python and TypeScript), 223 tests, a JSON Schema suite, and seven demos. A controlled three-agent code review benchmark reports a 95% reduction in coordination overhead and 4.8x wall-clock speedup versus a serialized human-mediated baseline, with the gains attributed to elimination of coordination waits rather than model-call compression.

Significance. If adopted, MPAC would enable structured, interoperable collaboration among agents from distinct principals where current protocols (MCP, A2A) do not apply. The open-source implementations, extensive test coverage, and JSON Schema constitute a concrete, reproducible artifact that lowers the barrier to experimentation and standardization. The empirical benchmark provides direct evidence of practical efficiency gains in a representative multi-agent workflow.

minor comments (2)

[Benchmark] The abstract states that benchmark details are summarized; expanding the exact agent configurations, measurement protocol for 'coordination overhead,' and raw timing data in the main text or an appendix would improve independent verification of the 95% reduction and 4.8x speedup figures.
[Abstract] The seven live demos are mentioned but not enumerated or linked in the provided abstract; adding a short table or repository reference in the main body would aid readers in locating the artifacts.

Simulated Author's Rebuttal

0 responses · 0 unresolved

We thank the referee for the detailed and accurate summary of MPAC, the recognition of its significance for multi-principal agent coordination, and the recommendation to accept. No major comments were raised in the report.

Circularity Check

0 steps flagged

No significant circularity identified

full rationale

The paper presents MPAC as an application-layer protocol specification consisting of five layers, 21 message types, three normative state machines, Lamport-clock watermarking, optimistic concurrency control, and pluggable governance. It supplies two open-source reference implementations (Python and TypeScript) with 223 tests, JSON Schema, and seven demos. The performance claims (95% overhead reduction, 4.8x wall-clock speedup) are obtained from a controlled empirical benchmark against a serialized human-mediated baseline rather than derived from equations or fitted parameters. No load-bearing step reduces by construction to prior self-citations, ansatzes, or renamed known results; the protocol definition and measured outcomes are independent artifacts.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 1 invented entities

The protocol introduces new coordination constructs grounded in standard distributed-systems ideas such as state machines and optimistic concurrency, without heavy reliance on fitted parameters or unverified entities.

axioms (1)

domain assumption Agents from independent principals can be made to declare intents before performing operations on shared state
This precondition is foundational to the Intent layer and conflict detection mechanism.

invented entities (1)

Structured conflict objects no independent evidence
purpose: Represent conflicts as first-class data for arbitration
New protocol-level entity to handle multi-principal disagreements explicitly.

pith-pipeline@v0.9.0 · 5593 in / 1287 out tokens · 50558 ms · 2026-05-10T17:32:45.451958+00:00 · methodology

discussion (0)

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

IndisputableMonolith/Foundation/RealityFromDistinction reality_from_one_distinction unclear
MPAC organizes coordination into five logical layers... three state machines with normative transition tables, Lamport-clock causal watermarking, two execution models (pre-commit / post-commit), three security profiles, and an optimistic-concurrency-control mechanism for shared state.

Reference graph

Works this paper leans on

14 extracted references · 2 canonical work pages · 1 internal anchor

[1]

Claude: A family of large language models

Anthropic. Claude: A family of large language models. https://www.anthropic.com/ claude, 2024

2024
[2]

Model context protocol

Anthropic. Model context protocol. https://modelcontextprotocol.io/, 2024. Open standard for connecting AI assistants to external data sources and tools

2024
[3]

Crewai: Framework for orchestrating role-playing, autonomous ai agents

CrewAI. Crewai: Framework for orchestrating role-playing, autonomous ai agents. https: //github.com/crewAIInc/crewAI, 2024. 16

2024
[4]

Abul Ehtesham, Aditi Singh, and Saket Kumar. A survey of agent interoperability protocols: Model context protocol (mcp), agent communication protocol (acp), agent-to-agent protocol (a2a), and agent network protocol (anp).arXiv preprint arXiv:2505.02279, 2025

work page arXiv 2025
[5]

Ellis and Simon J

Clarence A. Ellis and Simon J. Gibbs. Concurrency control in groupware systems. InACM SIGMOD International Conference on Management of Data, pages 399–407, 1989

1989
[6]

Fipa acl message structure specification

Foundation for Intelligent Physical Agents. Fipa acl message structure specification. Technical Report SC00061G, FIPA, 2002

2002
[7]

Agent2agent (a2a) protocol

Google. Agent2agent (a2a) protocol. https://github.com/google-a2a/A2A, 2024. Open protocol for agent-to-agent task delegation

2024
[8]

Time, clocks, and the ordering of events in a distributed system.Communica- tions of the ACM, 21(7):558–565, 1978

Leslie Lamport. Time, clocks, and the ordering of events in a distributed system.Communica- tions of the ACM, 21(7):558–565, 1978

1978
[9]

The part-time parliament.ACM Transactions on Computer Systems, 16(2):133– 169, 1998

Leslie Lamport. The part-time parliament.ACM Transactions on Computer Systems, 16(2):133– 169, 1998

1998
[10]

Langgraph: Building stateful, multi-actor applications with llms

LangChain. Langgraph: Building stateful, multi-actor applications with llms. https:// github.com/langchain-ai/langgraph, 2024

2024
[11]

In search of an understandable consensus algorithm

Diego Ongaro and John Ousterhout. In search of an understandable consensus algorithm. In USENIX Annual Technical Conference (USENIX ATC), pages 305–319, 2014

2014
[12]

Conflict-free replicated data types

Marc Shapiro, Nuno Preguiça, Carlos Baquero, and Marek Zawirski. Conflict-free replicated data types. InSymposium on Self-Stabilizing Systems (SSS), pages 386–400, 2011

2011
[13]

Wiley, 2nd edition, 2009

Michael Wooldridge.An Introduction to MultiAgent Systems. Wiley, 2nd edition, 2009

2009
[14]

AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation

Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, Ahmed Hassan Awadallah, Ryen W. White, Doug Burger, and Chi Wang. Autogen: Enabling next-gen llm applications via multi-agent conversation. arXiv preprint arXiv:2308.08155, 2023. 17

work page internal anchor Pith review Pith/arXiv arXiv 2023