For the past two years, every platform built its own way for AI agents to reach tools, data, and other agents. That era is closing: open protocols for tool access and agent-to-agent communication are being adopted across the major model and cloud vendors simultaneously. This is one of those infrastructure shifts that looks boring and changes everything downstream — especially what you should be asking vendors before you sign.
Key takeaways
- Open protocols for tool access and agent-to-agent communication are landing across major vendors at the same time.
- Integration work built against the standards outlives any single model or platform choice — the connective tissue becomes portable.
- Standard boundaries make every tool call something you can log, gate, and review — governance shifts from custom engineering to configuration.
- Ask vendors which open protocols they speak natively. The answer predicts your switching costs better than any roadmap slide.
Why standards change the buying math
Before: every integration was bespoke
An agent that could read your ticketing system on one platform had to be rebuilt to do the same job on another. Switching vendors meant rewriting the connective tissue — which is exactly the lock-in platform vendors were counting on. The integration budget wasn't buying you an asset; it was buying you a liability with a renewal date.
After: the connective tissue is portable
With standard protocols, the integration work we do for a client — connecting an agent to the ERP, the document store, the approval queue — outlives any single model or platform choice. Build it once against the standard, and the model behind it becomes a swappable part. That inverts the depreciation: the integrations appreciate as you add capabilities on top, and the model — the piece that improves fastest — is the piece you can replace most cheaply.
What this means for governance
Standard interfaces also make agents auditable in a consistent way: every tool call crosses a boundary you can log, gate, and review. That matters enormously for the regulated and government-adjacent organizations we serve — approval gates and audit trails stop being custom engineering and start being configuration.
The same boundary supports something subtler: least privilege for agents. When every capability an agent has is a declared connection rather than code buried in a platform, you can enumerate what it can touch, strip what it doesn't need, and prove both to an auditor. A person still approves the consequential actions — the standards just make the approval point a real place in the architecture instead of a promise in a slide.
Portability isn't a convenience feature. It's the difference between owning your automation and renting it.
What to ask your vendors
- Which open protocols do you speak natively — and which only through a proprietary adapter we'd have to maintain?
- If we switched models next quarter, which of our integrations survive unchanged?
- Where do tool calls get logged, and can our security team read that log without your help?
- Can we run the same agent against a different vendor's runtime as a test — today, not on the roadmap?
Where this is heading
The likely next chapters are discovery and delegation: registries where agents find each other's capabilities, and standard ways to hand a task from one organization's agent to another's with credentials that don't leak. None of it is settled yet, and we'd caution against buying futures. But the direction is clear enough to act on now: build against the standards that exist, and keep the proprietary surface area of your stack as thin as you can.
We build on open standards wherever they exist — it's part of being genuinely model- and cloud-agnostic. This briefing pairs with our notes on reasoning models and on-device models — portable integrations and portable inference are two halves of the same buying position. Read how we think about trust and governance, or see what we build in custom AI applications.