It’s probably unsurprising to regular readers of this Substack that Agentic AI is evolving fast, but without shared protocols for communication, tool use, memory, and trust, these systems will remain siloed. To unlock their full potential, we must build an open, interoperable stack — an Internet of Agents.
Today’s agents can reason, plan, and act autonomously within bounded environments. But real-world tasks cut across platforms and domains. That demands agents who can collaborate, delegate, and share knowledge across organisational and technical boundaries. Like the early internet, we’re missing the protocols, and without them, scale and composability will stall.
The Interop Problem: Closed Agents, Fragmented Ecosystems
AI agents operate efficiently within their native ecosystems, like Microsoft, NVIDIA, OpenAI, Meta, Google, ServiceNow, Salesforce, or frameworks such as LangChain, PydanticAI, or LlamaIndex, but their integrations across ecosystems and platforms remain costly, brittle, and non-scalable. Their toolchains, memory models, comms protocols, and access layers are tightly coupled to their execution environments. There's no shared grammar for agents to delegate tasks, invoke tools, or share memory across boundaries.
We're in the pre-TCP/IP era of agents: powerful local nodes, no scalable network.
Enabling Cross-Agent Collaboration: Core Interop Dimensions
Interoperability isn’t a single spec – it’s a stack. Here are the key architectural dimensions where we need standards or shared patterns:
Tool Use & Invocation
Standardised, agent-aware tool interfaces built upon existing protocols like OpenAPI, JSON-RPC, or GraphQL. This could involve agent-centric enhancements to enable reasoning about tool semantics, capability descriptions, and dynamic binding at runtime.
Example: Model Context Protocol (Anthropic), Agent Communication Protocol (IBM/BeeAI)Agent Communication & Messaging
A protocol layer for agent-to-agent messaging, task delegation, and negotiation. Needs standard message schemas, status codes, and handshake patterns.
Example: AGNTCY (Cisco, LangChain, LlamaIndex, glean, Galileo), Open Voice Interoperability (Linux AI & Data Foundation)Authentication, Identity & Trust
Decentralised identities (such as W3C’s DID standard) could provide signed claims, robust access control mechanisms, and Zero Trust-inspired frameworks. This area remains highly experimental but crucial.Memory & Context Sharing
Shared embeddings, vector memory formats, and cross-agent context windows. Could involve portable context objects or standardised episodic memory APIs.Example: Letta’s stateful agents
Knowledge Exchange & Inference APIs
Protocol extensions beyond RAG to enable multi-agent collaborative inference, where agents transparently query each other’s knowledge bases, exchanging reasoning steps and provenance details.Economic Transactions
Agents will require standardised frameworks for economic interactions, such as micropayment systems, metered billing APIs, escrow services, and agent reputation scores.
Example: Stripe’s Agent Toolkit is a great prototype.Governance & Policy Compliance
Embeddable policy engines (e.g. Rego/OPA-style) that allow agents to reason over compliance constraints, licenses, and regulations. Crucial for cross-domain agents.Discovery & Capability Matching
Registries, schemas, and semantic matching for agents to find and collaborate with others dynamically. Think DNS + service metadata for agents.Error Recovery & Conflict Resolution
Shared patterns for fallbacks, retry semantics, conflict resolution (e.g. optimistic concurrency control across agents), and escalation paths.Still highly experimental.
Why This Matters
Without shared abstractions, the agent ecosystem will remain fragmented. AI engineers will be stuck writing brittle integrations, agents will hit capability ceilings, and the vision of general-purpose autonomous systems will stall.
Building this stack is not optional – it’s the prerequisite for scalable, composable, autonomous systems.
Some foundations are being laid. But the real work – defining agent-native protocols, runtime boundaries, state management models, and trust layers – is just beginning.
The Internet of Agents won’t be built by accident.
It’ll be engineered by us.
Nice post! Multiagent Protocols is indeed a good theme to think about in the context of Agentic. Just wanted to say, however, that protocols is a more general theme and that there has been tremendous progress in modeling, verifying, and implementing multiagent interaction protocols. You can find some software here: https://gitlab.com/masr/
and papers about the software here: https://www.lancaster.ac.uk/staff/chopraak/
We are currently extending the tool suite in many ways. Happy to chat further!
Best
Amit Chopra
You should connect with Ockam. They've built the hard parts of this. Reach out to Mrinal their CTO.