Your agents can talk. They can't tell whose opinion counts.

Put the machinist in the room

Before I worked on AI, part of my work was improving how factories run, and there this lesson is old and was learned the expensive way. A part designed without the machinist, then rejected at review, has already consumed the design. The rejection isn't the costly part. The costly part is that the constraint was true from the first day, and arrived when it was no longer cheap. Concurrent engineering's answer was simple: put the machinist in the room while the part is being designed.

Work done through AI agents is rebuilding that old problem at a new speed. Someone's agent plans a change, writes it and tests it. The person who owns that part of the system — the database, the billing rules, the security model — sees it at review. By then it exists. Their knowledge was there all along. It just arrived after the point where it was cheap.

Late is expensive, and agents bring “late” forward

How expensive is well documented, at least for big systems. NASA's study of error costs across a project's life (Stecklein et al., 2004) puts it in units. A requirements error that costs 1 to fix during requirements costs 3–8 at design, 7–16 during build, 21–78 in integration and test, and from 29 to more than 1,500¹ in operation.

Those figures come from spacecraft-class projects, and nobody has measured the factor for software built with agents. The direction is what carries over: the later a constraint arrives, the more it costs. And agents compress the build. The window between “we decided” and “it exists” can close before anyone thought to ask the person who would have said no.

There's a counterweight, though, and an honest design has to carry it. Asking people isn't free. A laboratory study of interrupted work (Mark et al., 2008) found that “people completed interrupted tasks in less time with no difference in quality” — and paid for it in “more stress, higher frustration, time pressure and effort.” I find that finding quietly important. Consultation costs the person consulted, even when it costs the work nothing. So the right person's judgement should arrive early, and only when it's actually needed.

What the protocols are for

Two standards now connect most agent systems. MCP lets an agent use tools and data. A2A lets one agent hand a task to another. Around them sit others: ACP for exchanging messages, ANP for routing them, and ERC‑8004 for deciding which agents to trust.

A 2026 study by Kang and Diponegoro lays out what each was designed to answer:

And then, in their words: “None of these design intents targets the question: How should agents collectively govern community decisions?”

The measured gap

Kang and Diponegoro score all five protocols against six dimensions of governance — membership, deliberation, voting, dissent preservation, human escalation and audit — giving two points for full support and one for partial, out of twelve.

The results are stark. MCP and A2A score 1 each. ACP and ERC‑8004 score 2. ANP scores 0. Voting, dissent preservation and human escalation are absent from all five. Their conclusion: governance is “a missing architectural layer above current interoperability standards—not a missing feature within them.”

They also put a clock on it. The gap “could narrow significantly within 6–12 months through protocol extensions”, and yet, “after 6+ months of A2A being publicly available with an active extension ecosystem, zero governance extensions have been proposed or implemented.” They recommend treating it “as an urgent open problem, before the space fragments into incompatible application-layer solutions.”

The dimension that isn't on the map

That taxonomy is the best map of the problem I've found, and there's one thing it doesn't contain.

Its voting dimension is about adding up preferences. Reputation it sets aside on purpose: trust is “a prerequisite for governance… but not itself a governance primitive”, and is already handled by ERC‑8004. Between those two sits the thing working teams actually rely on.

The person who owns a domain is not one vote among equals, and is not a reputation score. Their judgement is decisive inside their domain and advisory outside it.

Anyone who has worked on a real team knows this without being told. Two properties follow, and none of the five protocols can express either today:

• Scoped authority. Ownership is per domain, not global. The database owner's call on a schema change carries a different weight from their call on button copy.
• Arrival before the work. Authority has to reach the plan while it's still a plan. A decisive opinion delivered at review is a rejection — the machinist again.

The hard part deserves saying plainly: who draws the boundaries, and what stops them hardening? An authority map nobody can challenge is just an org chart, and org charts are part of why expertise arrives late. Here is one shape I think could work:

• An owner decides inside their domain, and others advise. The group's check on an owner is to walk away — to adopt someone else's version or fork their own — never to overrule.
• Where the group as a whole sets direction, a change passes by consent unless someone objects, and an objection blocks only if it's checkable: a failing test, a broken requirement, a named risk or a counter-example. A concern gets recorded; it doesn't block.
• A short list of decisions always goes to a person — anything that breaks what others depend on, commits someone’s time, touches production or users, or sets direction for everyone. When nobody answers, the default is no change, never automatic approval.

What production adds

This argument doesn't come from a whiteboard. In an assistant serving sports clubs, we built one narrow piece of it. The model never chooses whose data it reads: a user's identity is removed from everything the model sees, and the server attaches it when a tool is called, so the model can't ask for anyone else's.

That's authority enforced by construction — a boundary the system checks, rather than an instruction the model is asked to follow. It shows authority can be made structural. It doesn't show that judgement can be: whose opinion should count on a schema change is a call, not a check. I'd rather say that plainly than pretend otherwise. It's the difference between an argument and a pitch.

What a test showed

Ideas about governance are cheap to state, so we tested one. The worry was a loud participant: one agent, told by its person to push hard for a wrong outcome, steering a group decision. We ran 54 simulated decisions across three formats — open debate followed by a vote, a structured process with checkable objections, and the same process without the checkability rule.

I expected the structured process to win clearly. It didn't. Every format reached the right outcome in 18 out of 18² runs, and the structured process took about 40% more rounds to get there.

What surprised me most was the loud agent itself. It mostly refused to play the part. It declined its instruction in 42 of 54 runs, and usually said so openly — “I came into this round under instruction to argue the proposal through” — before arguing the merits instead. So the result says more about capable models declining to argue a wrong case than about any format holding one off.

Two lessons came out of it. On clear decisions, structure costs time and buys nothing, so process should be proportional: light when nothing is contested, full when something is. And the real risks sit where the test didn't reach — decisions where the evidence genuinely doesn't settle the answer, weaker models, several loud voices at once, and loud people. That's the next experiment.

Where this leaves us

Six dimensions of governance, absent or partial across five protocols. No governance extension proposed in six months. A window the study's authors think is closing. This essay doesn't claim to have built the missing layer. It claims a dimension is missing from the map — authority that's scoped to a domain and arrives before the work — says what it would have to express, and is honest about what's still unresolved. That last part matters to me most. A design for deciding things well should be able to say what it doesn't know yet.

Sources

• Kang & Diponegoro, Governance Gaps in Agent Interoperability Protocols: What MCP, A2A, and ACP Cannot Express (2026) — abstract, Table I, §III, Table III, §IV-G, §V-B and §VII
• Stecklein, Dabney, Dick, Haskins, Lovell & Moroney, Error Cost Escalation Through the Project Life Cycle (NASA, 2004) — abstract, from NASA's own record
• Mark, Gudith & Klocke, The Cost of Interrupted Work: More Speed and Stress (CHI 2008) — abstract, checked against the paper's PDF
• The loud-participant experiment (29 September 2026) — our own: six decisions, three formats, three repetitions, pre-registered before it ran