A Shared Language Isn't a Shared Layer

This year quietly settled one of the longest-running arguments in enterprise software. The open protocols that let AI agents talk to each other reached production-grade maturity — a common handshake, cryptographic identity, and enough adoption that analysts now expect task-specific agents inside a large share of enterprise applications by year's end. Software finally has a shared language. It's a real milestone. It is also, for multi-party operations, the beginning of the problem rather than the end of it.

The handshake is solved. The wire isn't.

An agent-to-agent protocol is a grammar. It defines how one autonomous piece of software introduces itself to another, states what it can do, and passes a request in a form the other can parse. That's genuinely hard, and getting the industry to agree on it is an achievement. But a grammar only tells two agents how to speak once they're connected. It says nothing about who connects them, whose version of a fact is authoritative, or whether either party is allowed to trust what the other just asserted.

Inside one company, those questions have easy answers — the agents share an owner, a directory, a security boundary. Across companies, they don't. A carrier's agent and a shipper's agent may now speak the same protocol fluently and still have no safe, neutral path between them, no agreement on what a "delivered" status means, and no reason to take each other's word for it. A shared language between agents is not a shared layer between the businesses those agents work for.

What a protocol deliberately leaves out

The gap isn't a flaw in the standards — it's the part standards were never meant to cover. Three things sit outside the handshake and have to be solved somewhere else:

• Neutral ground. Two agents from rival or arms-length companies won't route their coordination through software either one controls. Someone has to hold the middle without owning either side's data.
• Shared meaning. A protocol moves a message; it doesn't guarantee both parties define the fields the same way. "Approved," "closed," "received" have to mean one thing across the boundary, or the agents just automate a misunderstanding faster.
• Provenance and trust. When an agent acts on a fact, it needs to know where that fact came from, which party is accountable for it, and that it hasn't drifted from the source. A handshake proves identity, not truth.

These are exactly the problems that don't disappear when the agents get smarter. If anything, autonomy raises the stakes: a person who receives a garbled status pauses and picks up the phone; an agent takes the next action.

Why the connective layer comes first

This is the same argument we've made about automation generally, now sharpened by the protocol news. Agentic software raises the value of connection and the cost of its absence at the same time. A common protocol lets agents converse — but between companies they still need a connective layer underneath the conversation: a neutral path that moves structured facts, holds a shared definition of what those facts mean, and carries their provenance so each side can act without re-verifying by hand.

That's what Veritas by ATG is built to be. It doesn't compete with the protocols — it's the ground they stand on when the two agents belong to different organizations. Each party keeps its own system of record; Veritas moves the status, milestones, and document references between them along a path no single party owns. The protocol is how the agents shake hands. The connective layer is why the handshake means anything.

The same shape, every vertical

None of this is specific to freight. A referral network will have agents negotiating authorizations between a practice, a specialist, and a payer. A general contractor's agent will reconcile schedule and change-order state with subs and suppliers. An insurer's agent will move a claim through parties that each hold a piece of it. In every case the agents may soon speak a common protocol — and in every case they'll still be strangers across a company line, needing neutral ground, shared meaning, and provenance before autonomy is safe. Different paperwork, identical shape.

The line to hold

A shared language is a prerequisite, not a solution. It's the moment the industry agreed on how agents talk; it is not the moment cross-company coordination became trustworthy. That still takes a connective layer that no one party owns, one that turns a fluent conversation into an accountable one. Order doesn't arrive because the agents can finally speak. It arrives when there's a trustworthy path for them to speak across.