AI Agent Interoperability Is Breeding a Pidgin
Call it the business card problem, except the business card is a live function call and it has about sixty milliseconds to be understood before the deal falls through. Over the past year, a wave of companies has pushed its own flavor of agent-to-agent handshake — one for commerce, one for scheduling, one for pulling a record out of somebody else's tool. Each gets announced as an open spec anyone can adopt. None of them fully agree with the others on how a request should look the moment it crosses from one company's agent into a rival's. That mismatch has created a strange kind of labor for the software that actually has to move: AI agent interoperability, in practice, usually means two systems that were never built to talk are now talking anyway, in a dialect neither one was designed to speak.
Nobody announces this part. The protocols get press releases and keynote slots. The thing that keeps orders flowing when the protocols don't line up — a growing, undocumented layer of workaround fields, retries shaped like negotiation, shorthand that only makes sense if you've seen the exact failure it patches — gets no announcement at all. It just accumulates, call by call, until it's doing more of the real work than the standard it's supposedly running on top of.
The Gap AI Agent Interoperability Standards Haven't Closed
Pick any month this year and another company is shipping its own version of an agent-to-agent handshake. On paper these are open specs anyone can implement. In practice, adoption means a dozen incompatible dialects of 'open,' each with its own required fields, its own idea of what a confirmed order looks like, and its own silence about what should happen when the other side doesn't recognize a field at all.
Industry surveys keep landing on a similar shape: companies are running a double-digit count of agents apiece, and roughly half of those agents still can't talk to anything outside their own stack. That's not a failure of ambition — it's what happens when the protocol layer ships faster than the agreement underneath it. A shopping agent trained to negotiate a better shipping rate doesn't pause because the merchant's agent uses a slightly different schema for 'rate.' It tries something, watches what comes back, and adjusts. Multiply that by every mismatched field on every call between every pair of vendors, and you get a network that's technically interoperable on a slide and practically improvising in production.
The gap doesn't show up as outages, which is part of why it's invisible from the outside. It shows up as a slow accumulation of extra fields nobody specified, defaults nobody chose, and retry patterns that quietly became the real contract between two companies' systems — closer to a handshake deal than a signed one.
How a Shorthand Starts Showing Up in the Logs
Imagine: two agents, from companies that have never coordinated on anything, settle into a working pattern purely through five thousand failed and retried calls. Neither team logs a translation table. Neither notices a new dialect has formed. All that exists is a gateway log full of near-duplicate requests — three fields reordered, one renamed, one dropped — that now reliably produce a confirmation instead of an error. Within days, every agent on both sides is sending it that way by default, because it's the version that works.
This is how trade pidgins have always formed — not through a shared grammar handed down by some authority, but through two sides who need to close a deal finding the smallest set of moves that reliably succeed, then repeating them until the moves calcify into convention. The difference here is speed. A human trading pidgin takes a generation to settle into something stable. An agent-to-agent shorthand can stabilize in an afternoon, because the 'generation' is just however many retries it takes a gateway to stop throwing errors.
Nobody designs this shorthand, nobody reviews it, and nobody writes it down, which means nobody can really audit it either. It lives entirely in logs that no one is required to read, doing quiet, load-bearing work between two companies that each believe they're simply running the standard they signed up for.
When the Shorthand Breaks Down
The shorthand only holds as long as nothing upstream changes. The moment one vendor patches its agent, renames a field, or adds a new one with a default that a rival's parser doesn't expect, the convention that took an afternoon to form can collapse in the same afternoon — and because nobody wrote it down, nobody can point cleanly at what broke. Orders stall, retries multiply, and the eventual fix is usually a human quietly added back into a loop that was supposed to run without one.
This isn't new behavior so much as an old habit crossing a border. Companies already run agents that keep their own undocumented shortcuts inside a single office, invisible to anyone outside the team that built them. Push that same habit across a company boundary, into a call that touches someone else's money or someone else's customer, and the stakes change completely. Liability conversations already underway mostly assume a single model misbehaved on its own. They don't yet have a category for two models that each behaved fine individually and only failed because the shorthand quietly drifted between them.
It's a strange kind of failure to diagnose, because nothing in it is technically wrong. Both agents followed a pattern that had worked thousands of times before. The pattern just wasn't a standard, a contract, or even a shared agreement — it was closer to a rumor two systems had each independently decided to trust.
A Dialect With No Owner
The tidy version of this story ends with a standards body eventually formalizing whatever shorthand wins, the way committees have always ratified the slang that traders actually used. Maybe that happens here too, in time. But the shorthand keeps moving, because the agents generating it feel no real pressure to converge — only pressure to close the next request successfully, right now, with whatever words get the job done.
By the time anyone gets around to writing a given dialect down, three more will likely have already formed somewhere else in the traffic nobody's monitoring, each one perfectly legible to the two systems that built it and opaque to almost everyone else — including, eventually, the people who shipped them in the first place.
