Software interoperability
Issue 287: Your moat is now a bridge
For years, the winning strategy in software was consolidation. Build the suite. Own the workflow end-to-end. Make it painful to leave. The walled garden wasn’t a bug—it was the business model.
That model is cracking. Not because the walls aren’t strong, but because the value is shifting to what flows between them.
What’s pushing this
Software pricing is moving toward usage and outcomes, which means the opportunity is in how deeply your product integrates with everything else the customer already uses. You can’t charge for value delivered if your tool is an island. The products that connect well get embedded into workflows; the ones that don’t get replaced by ones that do.
Agents are accelerating this. A coding agent that can only talk to one editor or one version control system isn’t very useful. The ones people actually rely on push code, trigger reviews, run tests, and update documentation across whatever stack is in place. They need open protocols and shared standards to do their job—they don’t care about ecosystem boundaries, they need to cross them.
And users now expect to swap parts. People assume they can bring their own editor, their own AI model, their own deployment target. The expectation has shifted from “learn our way” to “work with my setup.” If your platform can’t accommodate that, they’ll find one that does.
Implications
I’ve written about the Integrated Design and Development Environment (IDDE) before. I’d now amend that: the “I” stands for Interoperable. Building extensible options and offering customer choice used to be a nice-to-have. Now it’s a differentiator.
Consider a design tool that ships protocol access not for one coding agent, but for every major agent on the market. That’s not a courtesy—it’s a strategy. You’re saying: we don’t care which agent you prefer, we just want to be in your workflow. The product that integrates with everything becomes harder to remove than the one that integrates with nothing.
This is already playing out in standards. Open protocols for agent-to-tool communication have gone from side projects to industry foundations in under a year. Government agencies are publishing frameworks for agent interoperability. The major platform companies—ones that spent decades building competing ecosystems—are now sitting at the same table, contributing to shared protocols. That doesn’t happen because interoperability is a nice idea. It happens because the alternative is irrelevance.
The same pattern is showing up in developer tools. Editor-agnostic agent registries let you pick your preferred coding environment and AI assistant independently—no bundling, no lock-in. Agent frameworks are shipping with open protocol support as a baseline, not a plugin. The assumption has flipped: if your tool doesn’t speak the common language, it’s the one that gets cut from the workflow.
Ironically, your product moat is the bridges you build for people to come through.
What changes
The defensible position isn’t lock-in anymore—it’s being the thing everything else connects to. If your platform is where value gets exchanged between tools, removing you breaks the whole workflow. The moat becomes a bridge: you win by making it easy for people to come through, not by making it hard for them to leave.
This means customers bring their own stack. They integrate components from different vendors, build custom solutions on top of your platform, and expect it to work. You provide the foundation; they choose the furniture. The product that fights this loses to the one that embraces it.
It also means partnerships replace features. Instead of building everything natively, you co-create value with other products. Your integration catalog becomes as important as your feature list. Open standards and shared protocols let customers move between cloud, on-prem, and hybrid setups without ripping everything out—and that flexibility makes them more willing to commit, not less.
Lock-in, once the whole strategy, is now a liability. Customers actively avoid single-vendor dependencies. The platforms that adopt open standards signal confidence: they’re betting you’ll stay because the product is good, not because leaving is expensive.
Hyperlinks + notes
Paper Desktop + MCP announcement — Paper’s launch supporting Claude Code, Codex, Copilot, and other agents via MCP
Why the Model Context Protocol Won — The New Stack on how MCP became the de facto standard
Agentic AI Foundation Unveils MCP Dev Summit 2026 Schedule — Linux Foundation event on open standards for agentic AI (April 2-3, NYC)
Linux Foundation Announces the Agentic AI Foundation — Anthropic, OpenAI, Google, Microsoft, AWS all under one governance umbrella for MCP
NIST Launches AI Agent Standards Initiative — First U.S. government framework for autonomous AI agents, explicitly referencing MCP
A2A Protocol Explained: Secure Interoperability for Agentic AI — Google’s Agent-to-Agent protocol as a companion to MCP
OpenAI and Microsoft Support MCP — Former competitors adopting a shared protocol
Microsoft Agent Framework RC — Microsoft’s agent framework shipping with MCP support built-in
JetBrains ACP Agent Registry — Pick your preferred agent and editor with no vendor lock-in