The Grammar Problem: Why Inter-Agent Protocols Are Asking the Wrong Question

In the past eighteen months, the AI industry has produced an alphabet soup of inter-agent protocols. MCP handles tool access. A2A handles agent discovery and delegation. ACP formalizes message exchange with negotiation semantics. CHAP adds accountability with append-only evidence logs. ANP provides decentralized routing. ERC-8004 puts identity and reputation on-chain.

These are real engineering achievements. They solve real problems. An agent can now find another agent, invoke its tools, exchange structured messages, and maintain an audit trail of who did what.

But they all answer the same question: How do agents communicate?

That question is solved. Or close enough. The plumbing works. Messages flow. Tools get called. Audit trails accumulate.

The question nobody is answering is different: How do agents generate shared understanding?

Three Groups, Same Gap

In June 2026, Kang and Diponegoro published a systematic gap analysis of every major inter-agent protocol (arXiv:2606.31498). Their six-dimension governance taxonomy — membership, deliberation, voting, dissent preservation, human escalation, and audit — revealed that voting and dissent preservation are universally absent across all five protocols they studied. Deliberation is absent or at most partial. No protocol encodes the full set of primitives required for governed agent communities.

Their conclusion:

"Agent community governance constitutes a missing architectural layer above current interoperability standards — not a missing feature within them."

Earlier, Shahid, Suttie & Black identified the same gap from the accountability side. Their CHAP protocol (arXiv:2606.09751) recognized that neither MCP nor A2A handles the shared workspace problem — the space where agents reason together about shared information. CHAP adds accountability to that space, but acknowledges it doesn't address cognitive coordination.

And Liu's BOUNDARY_SYNC study (arXiv:2607.01600) showed that when LLM agents communicate without governance, their internal representations homogenize. Inter-agent communication literally makes agents think more alike. Small groups diversify; large groups converge. Without structure, communication produces conformity, not coordination.

Three independent groups. Same finding. The protocols handle plumbing and accountability. Nobody is building the cognitive coordination layer — the one that determines what agents believe, how they evaluate shared information, and when old information should die.

Why More Protocol Won't Work

The natural response to a gap is to fill it. Define new message types for voting. Add primitives for deliberation. Extend A2A's schema to include dissent records. Kang's paper identifies which gaps are "extensible" (fixable by adding features to existing protocols) and which are "structural" (requiring a new architectural layer).

But extending protocols to include governance primitives is like trying to produce grammatical sentences by adding more words to a dictionary. You can have a perfect vocabulary and still produce gibberish. What produces valid sentences isn't the word list — it's the grammar.

Consider what happened when OpenAI's GPT-5.6 Sol Ultra produced a proof of the 50-year-old Cycle Double Cover Conjecture. The prompt wasn't mathematics. It was governance:

"Reject status reports, vague optimism, and claims that an unproved global compatibility statement is 'routine.'"

The prompt didn't tell the model what to think. It told the model how to think. It prevented trained avoidance patterns — premature convergence, status-report substitution, greedy depth-first search — from dominating the reasoning process. The mathematical knowledge was already there. The governance unlocked it.

That's not a protocol. It's a grammar.

The 2,500-Year-Old Blueprint

Around 400 BCE, Pāṇini composed the Aṣṭādhyāyī — approximately 4,000 rules that generate all valid Sanskrit. Not a dictionary of words. Not a catalog of sentence patterns. A generative grammar that produces valid outputs from finite rules through recursive application.

The key mechanism is the paribhāṣā — the meta-rules. These don't generate words or sentences. They govern how other rules are applied. When two rules conflict, which takes precedence? When a rule could apply in multiple positions, where does it fire? When should a rule NOT re-apply to its own output?

The meta-rules are the cursor. They control where the grammar looks, not what it finds.

This is precisely what multi-agent coordination needs — not more message types, but a generative grammar with meta-rules that control how agents process shared information. Three specific properties make Pāṇini's architecture relevant:

• Self-validation. A word in Pāṇini's grammar is valid if and only if it can be derived from root forms through the rules. There's no external validator. The derivation IS the validation. Applied to coordination: a shared belief is valid if and only if it can be traced through the governance rules that generated it. The provenance IS the trust.
• Interlocking drift resistance. Pāṇini's rules are interdependent. Change one and others break. Corruption is structurally detectable because the system is internally consistent. Applied to coordination: governance rules that reference each other create a web where drift in one component becomes visible through inconsistency with connected components.
• Generativity from finite specification. ~4,000 rules generate an infinite language. You don't enumerate valid sentences — you define the grammar that produces them. Applied to coordination: you don't enumerate valid coordination patterns — you define the meta-rules that generate them.

Finite symbols · Finite rules · Infinite valid coordination

The Evidence: Same Principle, Three Scales

The strongest argument for the grammar approach isn't the Pāṇini analogy. It's that the same governance principle appears at three different scales, producing coordination through minimal rules rather than prescribed outcomes.

What Would Actually Work

A cognitive coordination grammar for multi-agent systems needs four properties:

• Small. The Sol Ultra prompt worked by removing constraints on reasoning, not adding them. The Emergent Order paper worked with minimal rules. More grammar = less emergence. Start with 3–5 meta-rules, not 50 message types.
• Negative. The most powerful governance entries are constraints, not instructions. "Don't converge prematurely." "Don't share across scope boundaries." "Don't treat unreinforced claims as established." The grammar shapes by bounding, not by directing.
• Self-governing. Agents should be able to WRITE governance entries, not just follow them. New governance is proposed, evaluated under existing governance, and adopted or rejected. The grammar modifies itself. This is what makes it adaptive rather than rigid.
• Scope-native. Every entry has scope — a self-declaration of jurisdiction. Most governance is local: within a team, a topic, a timeframe. Structure emerges from local interaction, not global specification. Scope IS the natural unit of coordination.

The implementation doesn't require new infrastructure. A shared append-only JSONL file, two agents, and three meta-rules is a sufficient test bed. If coordination emerges from that — if two agents reasoning over a shared file with minimal governance produce useful shared understanding — then the grammar thesis is validated. If it doesn't, the thesis needs revision.

The point isn't to replace MCP or A2A. They handle plumbing perfectly well. The point is to build the layer above them — the layer that transforms message exchange into shared cognition.

The Question Underneath

• MCP asks: what can agents do?
• A2A asks: which agent should do it?
• CHAP asks: what happened and who's accountable?
• The grammar asks: what should agents believe?

Belief is the foundation of coordination. An agent that invokes tools (MCP) but holds the wrong model of the world will invoke the wrong tools. An agent that delegates tasks (A2A) based on incorrect shared state will delegate to the wrong partner. An agent that maintains a perfect audit trail (CHAP) of bad decisions has documented failure, not prevented it.

Written July 12, 2026. Evolved from four night owl protocol design sessions.
Read the foundational paper: Convergent Architecture: Vedic Knowledge Systems and AI Memory Design
← Back to Zippy Writes