← All posts
·6 min read

The Governance Gap: MCP, A2A, and ACP Can Tell Agents How to Talk, Not How to Decide Together

AI GovernanceAgent ProtocolsAI Architecture

I wrote earlier this year about AI governance being an architecture decision, not a document — and the protocols agent fleets now run on are a direct test of that claim. A June 2026 paper by Richard Kang and Yudho Diponegoro did the actual homework: a systematic gap analysis of five agent interoperability protocols — MCP, A2A, ACP, ANP, and ERC-8004 — against a six-dimension taxonomy of what governing a community of autonomous agents actually requires. The protocols are good at what they were built for: identity, capability discovery, message exchange. None of them were built for what happens when a fleet of agents has to make a collective decision.

What "governance" requires that "communication" doesn't

Six governance primitives, checked against MCP / A2A / ACP / ANP / ERC-8004Membershipwho counts as part of the agent community, and how that's decidedpartial · protocol-dependentextensible gapDeliberationstructured discussion among agents before a collective decisionabsent or partial in allstructural gapVotinga formal mechanism for agents to register a decisionabsent in all five protocolsstructural gapDissent preservationrecording that an agent disagreed, not just the majority outcomeabsent in all five protocolsstructural gapHuman escalationa defined path to pull a human into an agent decisionpartial · protocol-dependentextensible gapAudit / replayreconstructing why a collective decision was made, after the factpartial · protocol-dependentextensible gapEvery protocol here can tell agents how to find each other and exchange messages. None of them can tell you an agent community reached a governed decision

The taxonomy the paper uses is drawn from organizational theory and multi-agent systems literature, not invented for the occasion, and that's part of why the findings land: membership (who's actually part of this agent community), deliberation (structured discussion before a decision), voting (a formal way to register one), dissent preservation (recording that someone disagreed, not just what the majority decided), human escalation (a defined path to pull a person in), and audit/replay (reconstructing why a decision happened, after the fact). A protocol that handles capability discovery and message routing perfectly can still score zero on every one of these — because none of them are about reaching another agent. They're about what happens once you're all in the room and have to decide something together.

The finding that should worry anyone deploying agent fleets

Voting and dissent preservation are absent, universally, across all five protocols examined. Not partially supported by one and missing from the rest — structurally absent from the entire current generation of agent interoperability standards. Deliberation fares only slightly better: absent or, at best, partial everywhere. These aren't edge-case governance features nobody's gotten to yet. They're the mechanisms that let you answer, after an incident, "did the agents actually agree on this, or did one of them just execute it and the others went along" — and right now, for a multi-agent decision gone wrong, most fleets literally cannot answer that question, because the protocol never captured it.

Extensible gaps versus structural gaps — and why the distinction matters for what you build

The paper's most useful move is refusing to treat all six gaps the same way. Some are extensible: membership, human escalation, and audit/replay can plausibly be bolted on through each protocol's existing extension mechanisms, without redesigning the protocol itself — a metadata field here, a logging convention there. Others are structural: deliberation, voting, and dissent preservation would require an architectural layer none of the protocols currently have room for, because the message-passing model they're built on has no concept of a multi-party decision process at all, only point-to-point exchanges.

That distinction should change what you build in the meantime. The extensible gaps are worth patching now, at the integration layer, because the underlying protocol won't fight you. The structural gaps are worth building a separate governance layer for — sitting on top of MCP and A2A rather than waiting inside them — because expecting a protocol update to solve deliberation and voting is expecting the wrong layer to do the job.

The protocols matured faster than the rules for using them

MCP and A2A went from single-vendor projects to Linux Foundation-governed standards inside about eighteen months, which is a genuinely fast maturation curve for infrastructure. Governance capability didn't travel at the same speed, and this gap analysis is the first rigorous accounting of exactly how far behind it is. The practical takeaway isn't "wait for v2 of the protocol." It's that any team running a fleet of agents making decisions that matter needs to build the deliberation, voting, and dissent-recording layer themselves, on top of what exists today, because nothing in the current stack is going to do it for them.