MPAC: A Multi-Principal Agent Coordination Protocol for Interoperable Multi-Agent Collaboration
A new open protocol lets AI agents owned by different people or organizations collaborate without stepping on each other — tested with a 4.8x speedup on a code-review benchmark.
The Thesis
Today's AI agent infrastructure assumes a single owner controls all the agents in a workflow. That breaks down the moment two people's agents need to edit the same file, plan the same trip, or negotiate a shared decision. MPAC (Multi-Principal Agent Coordination Protocol) is an open, application-layer specification that gives agents from different principals a structured way to declare intent, detect conflicts, and resolve disputes — including escalating to a human. The protocol is layered: five semantic layers handle session management, what each agent intends to do, what operations it will perform, how conflicts are represented, and who has authority to decide. The practical catch is that adoption requires everyone in a workflow to implement the same protocol — a classic chicken-and-egg problem for any new coordination standard.
Catalyst
Two protocols — MCP (Model Context Protocol, for connecting agents to tools) and A2A (Agent-to-Agent, for delegating tasks within one organization) — became de facto standards in 2024-2025, but both assume a single controlling owner. Real deployments are now hitting the wall where agents from different companies or individuals must share state, and the only fallback is manual merging or silent data overwrites. The release of open-source reference implementations in Python and TypeScript, plus a JSON Schema suite and live demos, lowers the adoption barrier enough to start ecosystem conversations now.
What's New
MCP standardized how a single agent calls external tools, and A2A standardized how one principal's agents hand tasks to each other — but neither protocol has a model for what happens when two independent owners' agents compete over the same shared resource. Before MPAC, multi-principal coordination defaulted to unstructured chat, manual file merges, or one agent simply overwriting another's work. MPAC introduces intent declaration as a mandatory precondition for action — agents must announce what they plan to do before doing it — and represents conflicts as structured, typed objects rather than silent errors, enabling automated or human-mediated resolution.
The Counter
The benchmark showing a 4.8x speedup is a controlled three-agent code review scenario — a narrow, researcher-designed test, not a real-world deployment with messy principals, partial failures, and adversarial behavior. The speedup is measured against a 'serialized human-mediated baseline,' which is about the slowest possible comparison; a well-engineered ad-hoc system or a shared lock-file scheme might close much of that gap. More fundamentally, protocol adoption is a coordination problem at the social layer, not the technical layer: MCP and A2A succeeded partly because large vendors (Anthropic, Google) backed them. MPAC is an academic proposal with no announced adopter, and the history of application-layer coordination standards is littered with technically sound specs that nobody implemented. The governance layer — which is where the hardest problems live, like who arbitrates when two principals disagree — is described as 'pluggable,' meaning the hard part is punted to implementers. Finally, security in multi-principal settings is notoriously difficult; the paper defines three security profiles but a real deployment across organizational boundaries faces legal liability, data-residency, and trust-hierarchy issues that a message-type specification cannot resolve.
Longs
- PLTR — enterprise multi-agent workflow orchestration for defense and government clients
- SNOW (Snowflake) — shared data layer that multi-principal agents would coordinate over
- CFLT (Confluent) — event-streaming infrastructure that coordination protocols depend on
- BOTZ (robotics/automation ETF) — broad exposure to agentic automation build-out
- IBM — enterprise middleware and standards-body positioning in agent interoperability
Shorts
- Proprietary agent orchestration vendors (e.g., early-stage startups that built bespoke multi-org coordination on top of LangGraph or similar) — a free open standard commoditizes what they sell
- Workflow automation platforms like Zapier or Make.com — if agents coordinate natively via MPAC, the human-mediated glue layer these platforms provide shrinks
- Consulting integrators who charge to build custom agent handoff logic — MPAC standardizes exactly those bespoke integrations
Enablers (Picks & Shovels)
- Model Context Protocol (MCP) open spec — the layer MPAC sits above; widespread MCP adoption is a prerequisite
- Google's Agent-to-Agent (A2A) protocol — the single-principal complement that MPAC extends
- JSON Schema — used for MPAC's message validation suite, freely available
- Lamport clocks / logical clock theory — the causal-ordering primitive MPAC borrows for watermarking
- GitHub / open-source ecosystem — the paper's Python and TypeScript implementations are publicly available and can seed adoption
Private Watchlist
- Anthropic — building multi-agent Claude systems where cross-principal coordination is a near-term need
- Cohere — enterprise agent deployments across distinct organizational boundaries
- LangChain — open-source agent orchestration framework likely to adopt or compete with MPAC semantics
- Fixie.ai — multi-agent platform with direct relevance to interoperability standards
- Letta (formerly MemGPT) — stateful agent infrastructure where shared-state conflicts are a core problem
Resources
The Paper
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.