I once watched two agents agree on every message and still destroy a workflow.

They were both speaking A2A. The transport was perfect. The schemas validated. The task objects carried clean state transitions, the message history was intact, and every payload conformed to the contract. And the downstream system did the wrong thing anyway, because the policy agent said “flag high-risk cases” and the execution agent — a different model, fine-tuned by a different team, trained on a different corpus — had a completely different operational definition of “high-risk” than the one the policy team had in mind.

The logs looked fine. The word was shared. The policy was not.

That was the week I stopped believing that protocol compliance was the same thing as interoperability, and started treating shared vocabulary as the actual architectural problem.

The Layer I Kept Skipping

I had spent the better part of a year on protocols. MCP for tool access. A2A for peer delegation. I had schemas, I had Agent Cards, I had signed identities and structured handoffs. By every checklist I could find, my agents were interoperable.

They were not. They were connected.

The distinction has a precise name in the 2026 literature. A survey analyzing eighteen agent communication protocols organizes the field into three layers: communication (reliable transport), syntactic (structured messages and schemas), and semantic (meaning-level coordination). The paper's central finding is an imbalance: most protocols provide increasingly mature support for transport, streaming, schema definition, and lifecycle management, but offer limited protocol-level mechanisms for clarification, context alignment, and verification. As a result, semantic responsibilities are pushed into prompts, wrappers, or application-specific orchestration logic, creating hidden interoperability and maintenance costs.

That's exactly what I had done. I had built a beautiful syntactic layer and then written prompts to compensate for the fact that “risk,” “escalate,” and “verified” meant different things to different agents. The prompts were the symptom. The missing semantic layer was the disease.

The Stranger Problem paper states the gap with the precision I'd been lacking: MCP, A2A, and ANP “move requests, tasks, and payloads between agents built by different principals with growing reliability. They do not share meaning”. When two agents that have never met, each holding a private schema, arrive at a coordination boundary, no protocol governs how they establish semantic common ground. A payload arrives schema-shaped under the receiver's parser but wrong under the sender's intent, is consumed anyway, and propagates downstream. The paper names this hallucination relocated from a single model's output to the seam between agents, where it is harder to detect and easier to act on.

I had been debugging seams for months and calling it prompt tuning.

The Failure Is Silent by Design

The reason semantic mismatch is so much harder than syntactic mismatch is that it passes every check you have.

An API connector handles syntactic interoperability. It makes sure data is transferred in the right format — the equivalent of checking that a sentence has a noun and a verb. A semantic bridge handles meaning: it makes sure the nouns and verbs actually refer to the same thing in the real world. You can have two agents exchanging perfectly formatted JSON through an API and still have them completely misunderstand each other. The API connection works. The mission fails.

The canonical example is a diagnostic agent that finds a malignancy and flags the file with “positive result.” A downstream reporting agent, not understanding the medical context, interprets “positive” as a favorable outcome. Every schema check passes. The word is shared. The meaning is inverted.

I had a version of this in my own system. An extraction agent returned verified: true because it had confirmed the claim against the document it was given. The downstream synthesis agent read verified: true and treated it as externally corroborated — a much stronger claim. Neither agent was wrong about its own definition. The schema had no field that distinguished “true against this source” from “true against the world.” The semantic layer had been collapsed into a boolean.

Why Shared Vocabularies Drift

The second thing I hadn't understood is that a shared vocabulary isn't a static artifact you define once. It decays.

The Agent Drift paper identifies semantic drift as a distinct failure mode where agents deviate from intent over extended interaction — a risk bot slowly becoming an opportunist, a verification agent slowly treating confirmation as corroboration. The measured onset is uncomfortably early: detectable degradation starts after a median of just 73 interactions, and unchecked drift causes a 42% drop in task success while increasing human intervention costs by 3.2x.

The DOA framework, published in ZTE Communications, defines semantic drift as “a phenomenon where heterogeneous agents assign conflicting meanings to shared terminology due to differing internal prompts or domain knowledge”. Their diagnosis of the existing landscape is the one that matches what I built: existing paradigms either rely on unconstrained natural language, which suffers from structural vagueness, or rigid symbolic schemas that fail to adapt to emergent concepts.

That's the trap. Natural language feels safe because it's readable, but readability is not verification. Two agents can use the same token and apply it differently, and the failure is especially easy to miss because the transcript remains legible. Rigid schemas feel safe because they're precise, but they can't express a concept that emerged mid-workflow. My schema was precise about fields I'd anticipated and silent about distinctions I hadn't.

The SEMA paper names the underlying coordination bottleneck plainly: agents “must either re-explain concepts verbosely — risking semantic drift — or assume shared meaning from surface labels — enabling silent misalignment”. Those are the only two options a protocol without a semantic layer gives you.

What Actually Fixes It

I've now rebuilt around four mechanisms, and they operate at different layers. None of them is a complete answer on its own.

Behavioral certification of the vocabulary. The most rigorous approach I've found comes from Verifiable Semantics for Agent-to-Agent Communication, and its central move is unsentimental: it doesn't ask whether two agents “really” share an internal concept. It asks whether they give compatible answers when tested on the same observable events. A term enters the usable core only if the agents demonstrate sufficiently low disagreement on audited examples, and downstream reasoning is restricted to that certified core. When model updates or contextual drift corrupt the core, the system re-audits and renegotiates.

This is the mechanism I wish I'd built first. Instead of hoping “verified” means the same thing to both agents, you test it: show both agents the same twenty cases and check whether they classify them the same way. The ones they agree on become the certified vocabulary. The ones they don't become a flagged ambiguity that a human resolves — or that the workflow routes around.

Dynamic ontology alignment. DOA integrates a proactive semantic prober that detects conceptual mismatches and a neuro-symbolic aligner that reconciles local semantic structures in real time, grounding natural-language dialogue in an evolving shared ontology. The results are concrete: 31.5% average improvement in task success rates and 50% reduction in communication overhead compared to state-of-the-art baselines across cross-domain supply chain and healthcare scenarios. The framework also cuts average turns to consensus from 8.4 to 3.1 and tokens per task from 4,200 to 1,950.

The important design choice is that the ontology is evolving, not fixed. A static schema breaks the moment a concept emerges that wasn't anticipated. A dynamic ontology is a living artifact that the agents themselves help revise.

Verifiable words, not just shared labels. SEMA takes the most radical approach: it derives identifiers from the cryptographic hash of structured behavioral contracts, so that any divergence in the formal specification produces a distinct hash. The identifier functions simultaneously as a word in natural language and as a cryptographic proof that both agents are referring to the same behavioral contract. An initial bootstrap vocabulary of 453 patterns showed no observed semantic collisions and a 16.6× token compression ratio.

I haven't shipped SEMA, and I want to be careful not to oversell a research protocol. But the insight underneath it is the one I've adopted: the unit of verification should be the unit of communication. If two agents are going to coordinate on a term, the term should carry the evidence that they mean the same thing — not a prose definition that can be paraphrased, and not a schema label that can be silently reinterpreted.

An explicit semantic bridge as a component. The Lyzr glossary describes the Semantic Interoperability Bridge as a translation layer that ensures agents understand each other's meaning, not just exchange raw data. The analogy is two doctors in an emergency room, one trained in the US using “acetaminophen” and one trained in Europe saying “paracetamol” — the bridge doesn't just translate words, it ensures both know they're talking about the same drug at the same dose for the same patient.

In practice, for my system, this looked like a small, cheap classifier that ran before the main handoff and flagged any term whose operational definition differed between sender and receiver. It wasn't an LLM. It was a lookup table built from the certification tests, plus a fallback that escalated to an LLM only when the term wasn't in the certified set. The bridge is not glamorous. It's the thing that catches the mismatch before the action executes.

The Production Evidence

The ontology-driven approach shows up in production architectures, not just benchmarks. A 2026 framework for smart healthcare integrates MCP with a Mixture of Experts architecture, constructing a shared OWL-based ontology and defining action rules with SWRL so that agents “reason over shared knowledge and make context-aware decisions”. The paper's framing is direct: “effective interoperability and coordination remain critical challenges due to the lack of shared semantics and unified communication protocols”.

The IETF has a draft specification for a normative semantic layer for agent-to-agent interaction in the Internet of Agents, defining required classes and properties, a negotiation procedure, and alignment rules for heterogeneous ontologies. That's the standards body acknowledging the gap the protocol surveys identified: transport and syntax are solved, semantics is not.

Cisco's Outshift team frames it as a “Layer 9” problem. MCP and A2A provide syntactic connectivity — what they call “Layer 8” — which is necessary but insufficient for true collaboration. Without shared intent, agents are bound by their local training data and isolated objectives. A security agent demands strict controls that raise costs; a cost-optimization agent pushes to strip those protections away; the agents optimize past each other and stall the workflow. Their construction-site analogy is the one I keep coming back to: an electrician speaking German, a plumber speaking Japanese, and a carpenter speaking English, all with state-of-the-art walkie-talkies and no shared blueprint.

The walkie-talkies are the protocol. The blueprint is the vocabulary. I had spent a year on walkie-talkies.

What the Trade-Offs Actually Are

A semantic layer is not free, and I want to be honest about where it costs you.

It adds a component that can be wrong. A certification test that approves a term both agents interpret differently is worse than no certification, because it creates false confidence. The Verifiable Semantics approach mitigates this by making disagreement measurable — but the measurement itself has a false-negative rate, and you have to validate the validator.

It adds latency. DOA's alignment latency is 1.4 seconds per alignment, compared to 0.3 seconds for a fixed schema. The fixed schema is faster because it doesn't do the work. It's also the thing that fails when a concept emerges. You're trading speed for durability, and the trade only pays if your task actually involves heterogeneous agents with genuinely different vocabularies.

It requires governance. Who owns the ontology? Who approves a new term? What happens when two teams disagree about the definition? SEMA is explicit that “governance mechanisms for quality control at scale remain an open design problem”. A shared vocabulary is a political artifact as much as a technical one, and the moment it matters, it becomes contested.

And it can be overkill. If your agents are homogeneous — same model, same team, same domain — a fixed schema is fine. The semantic layer earns its keep when the agents are heterogeneous: different models, different teams, different training data, different organizational incentives. That's the regime the Stranger Problem identifies as dominant and unsolved: runtime semantic negotiation between strangers. If you're not in that regime, don't pay for it.

What I'd Tell My Past Self

Protocol compliance is a floor, not a ceiling. A2A can guarantee that a Task object arrives with the right state transitions. It cannot guarantee that “high-risk” means the same thing on both sides of the boundary.

The fix isn't a better prompt. A prompt is a prose definition, and prose definitions get paraphrased into drift. The fix is a semantic layer with three properties: a vocabulary that is tested behaviorally rather than assumed, an ontology that evolves rather than staying fixed, and a bridge that catches mismatch before the action executes rather than after the damage is done.

The teams that are getting this right aren't choosing between MCP, A2A, and a new protocol. They're building the layer that none of those protocols provides — the layer where “verified” means the same thing to the agent that wrote it and the agent that acts on it.

The walkie-talkies were never the hard part.

So here's my question: If you asked two of your agents to define the same term right now, would you get the same answer — or would you discover that your entire handoff protocol has been carrying a shared word with two different meanings?

I'd love to hear where you've landed. A behavioral certification test, an evolving ontology, a semantic bridge you built before you knew what to call it, or a prompt you're still defending — and what finally made you stop tuning the words and start testing the meaning?