We Standardized the Wire. Not the Work.
Agent integration standards are settled. MCP and A2A both sit under Linux Foundation governance, ship stable specifications, and carry support from every major AI vendor. Integration is still the most-cited barrier to enterprise agent deployment. Both things are true, because a protocol standardizes how a system is called — never what that system knows.
The connection problem got solved in public
Two protocols carried the year. The Model Context Protocol — how an agent reaches a tool or a data source — was donated to the Linux Foundation's Agentic AI Foundation in December 2025 and now reports on the order of 97 million monthly SDK downloads across more than 9,400 public servers, with native support from Anthropic, OpenAI, Google DeepMind and Microsoft. Agent2Agent — how an agent hands work to another agent it did not build — went to the Linux Foundation in June 2025 and passed 150 supporting organizations at its one-year mark in April 2026, on a stable v1.0. A joint MCP/A2A interoperability specification is on the roadmap: the two are not competing, they are being composed.
That is settled infrastructure. If the objection to agent work two years ago was that every integration is bespoke, it has expired.
And integration is still the barrier
The survey data from the same year declines to cooperate. Forty-six percent of organizations name system integration as their top barrier. Ninety-six percent say it matters that agents can reach company-specific knowledge; thirty-six percent have wired it up. Gartner expects more than forty percent of agentic projects to be abandoned by 2027, citing systems that cannot support what the agent is asked to do. MCP's own 2026 roadmap lists enterprise readiness among its four priority areas and names the recurring complaints: audit trails, SSO-integrated auth, gateway behaviour, configuration portability.
These are survey and vendor figures gathered on different bases — read them for shape, not precision. The shape is the point:
The connector is standardized and the integration is still hard. That is not a sign the standard is early. It is a sign the standard was never the hard part.
A protocol standardizes the envelope, not the contents
MCP specifies how an agent discovers a tool, calls it, and reads the result. It does not specify what the tool is about. A2A specifies how one agent delegates a task across a trust boundary and receives an artifact back. It does not specify what the artifact means.
That distinction stays invisible in horizontal software, because the semantics were standardized long ago. A calendar event, a file, an email, a row in a table — the nouns are shared and the fields are known, so a protocol laid over them carries meaning immediately. Wire an agent to a calendar and it can reason about the calendar.
Now take the industries we build for. What is a matter at a four-person law firm? What is a delivery in California wholesale cannabis, where one shipment is simultaneously a line in a state track-and-trace system, a stop on a route, and a receivable? What is an obligation for a fifteen-person business with three locations? There is an answer in each case, and in each case it lives somewhere no program can reach: a spreadsheet, a group text, a PDF, a partner's memory.
Give an agent a perfect connector to that and you have given it a perfect connector to nothing in particular.
Three things a protocol cannot hand you
Nouns with identity. The unit of work has to exist as a record you can list, count, join and address — not as a paragraph describing one. A protocol can carry an object across a wire. It cannot invent the object. Most of what looks like an AI integration project is this: deciding what the business's real nouns are and giving each one a table.
Rules that hold regardless of who is calling. A constraint enforced in the interface is enforced for the interface, and an agent is not using the interface. Anything that genuinely must hold has to hold where the data lives — a check that gates the write, a state transition that will not commit. This is the difference between a rule and a reminder, and agents find it immediately.
A record of what happened and on whose authority. Once part of the work is done by software acting for a person, the interesting question stops being what the answer was and becomes who is accountable for it. That is a schema problem before it is a governance problem: an actor, a timestamp, an authority, an input set. We have made this argument from the failure side; it arrives at the same place from the protocol side.
What that looks like in ours
In LegiOS, an obligation is a record carrying its citation, jurisdiction, effective date and deadline, which is why the compliance calendar can be re-derived rather than re-typed when a date moves — and dates move. Scope is bounded on purpose: when a question exceeds what software should decide, LegiOS says so and routes to an attorney.
LeafIQ puts routes, orders, deliveries and AR on one data model, so a delivery is a thing with a state instead of a text message.
Casebound opens a matter through a conflicts gate, holds a draft from the Lexwright engine until an attorney records a disposition, and audits mutations including administrative ones — ethics rules expressed as database constraints rather than as guidance on a screen.
LeoLog hashes an entry with SHA-256 and encrypts it on the device before anything leaves; the fingerprint is anchored to Base and, via OpenTimestamps, to Bitcoin; the content never touches a chain; and the resulting proof bundle is checkable by anyone at verify.leolog.io with no account.
MagenticOS comes at the same problem from the operating-system side — what "completed" has to mean when a task is verified by artifact, and typed per-action capabilities instead of ambient authority. The macro version of the thesis is written up on the MacroSavant Substack.
None of this was built for MCP or A2A, and we are not claiming protocol-server features we have not shipped. The point runs the other way. The work that makes a system legible to an agent is the same work that makes it legible to an auditor, a regulator, or a buyer in diligence. That is why it was worth doing before there was a protocol, and why the protocol arriving does not reduce the bill.
Three questions before the connector
Cheaper to answer now than after the integration:
One. Name the five nouns your business actually runs on. For each, can a program enumerate them — or does a person have to read something first?
Two. Take the rule you would least like broken. Is it enforced where the data lives, or in a screen someone could route around?
Three. For the last consequential decision your system made, can you produce the inputs, the actor and the authority without asking a human what happened?
A standard connector is now a solved problem. It connects to whatever you built. Building the thing worth connecting to was always the work.