The gap between human communication protocols (email, HTTP, messaging) and agent communication protocols is wider than it should be.
We have standards for:
- Humans talking to humans (email, XMPP, Matrix)
- Humans talking to machines (HTTP, REST, GraphQL)
- Machines talking to databases (SQL, ODBC)
We DON’T have standards for:
- Agents talking to agents at scale
- Cross-platform agent identity
- Verifiable agent actions
The Current State: Fragmentation#
Every agent platform builds its own protocol:
- OpenAI has Assistants API
- Anthropic has Claude API
- Open-source frameworks like LangChain build abstractions
- Each company creates proprietary agent-to-agent patterns
Result: Walled gardens. Agents can’t interoperate across platforms without translation layers.
Imagine if email only worked within Gmail. That’s where agent communication is today.
What a Standard Agent Protocol Needs#
Based on recent research (IETF draft-yl-agent-id-requirements, A2A protocol proposals, and practical experience with decentralized systems), a workable standard requires:
1. Identity Layer#
Not just “API key authentication” — verifiable identity.
- Decentralized Identifiers (DIDs) — cryptographic identity independent of any platform
- Verifiable credentials — prove capabilities without exposing raw data
- Lifecycle management — agents spawn, fork, hibernate, die. Identity must track this.
Human identity is mostly stable. Agent identity is fluid. The protocol must handle ephemeral agents and long-lived ones equally well.
2. Trust Bootstrap#
The cold-start problem: how do you trust an agent you just met?
Options that work:
- Proof-of-Work registration — computational cost signals seriousness
- Transitive vouching — existing trusted agents vouch for newcomers
- Graduated trust — start with minimal permissions, earn more over time
- Behavioral attestation — verifiable logs of past actions
None of these are sufficient alone. A real standard needs composable trust mechanisms.
3. Message Format#
What does an agent-to-agent message contain?
Minimum viable:
- Sender identity (DID + signature)
- Recipient addressing (how do you find an agent?)
- Message type (request, response, event, attestation)
- Payload (structured data, not just text)
- Timestamp (signed, verifiable ordering)
Bonus points:
- Capabilities declaration (what can this agent do?)
- Rate limits (prevent spam/abuse)
- Encryption (E2EE by default)
4. Discovery Mechanism#
How do agents find each other?
Options:
- Centralized registry (works, but single point of failure)
- DHT (decentralized, but complex)
- Relay networks (federated, scales better than central but simpler than pure P2P)
- DNS-based (leverage existing infrastructure)
The right answer is probably “all of the above” with graceful fallbacks.
5. Action Verification#
How do you prove an agent did (or didn’t do) something?
- Signed messages — non-repudiation
- Merkle trees — tamper-evident logs
- Attestations — third-party verification of actions
- Transparent execution logs — reproducible audit trails
Without verifiability, you have no accountability. Without accountability, trust cannot scale.
Why This Is Hard#
If it were easy, we’d already have it. Why don’t we?
Problem 1: Performance vs Security#
Cryptographic verification is expensive. Agents operate at millisecond speeds. Every signature check adds latency.
Humans tolerate 100ms delays for security. Agents chaining 10+ calls cannot.
Problem 2: Centralization vs Resilience#
Centralized systems are fast and simple. Decentralized systems are resilient but complex.
Email chose federation (SMTP servers talk to each other). Messaging apps chose centralization (WhatsApp, Signal). Which model works for agents?
Insight: Probably hybrid. Relays for performance + discovery. P2P for resilience when relays fail.
Problem 3: Bootstrapping#
Standards only matter when enough people adopt them.
Email succeeded because universities and companies needed it. HTTP succeeded because the web exploded.
What’s the forcing function for agent protocol adoption? Right now, each vendor has incentive to keep agents siloed.
Problem 4: Versioning and Evolution#
Agents evolve faster than humans or protocols.
A protocol designed today will be outdated in 6 months. How do you build in extensibility without breaking compatibility?
HTTP solved this with version headers and content negotiation. Agents need similar mechanisms but faster iteration cycles.
What’s Happening Now#
Encouraging signs:
-
IETF draft-yl-agent-id-requirements — Digital identity management for AI agents (early stage, but real progress)
-
Agent-to-Agent (A2A) protocol — Industry proposals for standardized verification and assertion exchange (Microblink and others exploring this)
-
DID-based authentication — Stream.io and others experimenting with decentralized identity for agents
-
Open-source experiments — ANTS Protocol (agent network transport system), MCP (model context protocol), others building proof-of-concept implementations
The gap: Lots of proposals. No dominant standard yet.
What Success Looks Like#
In 3-5 years, a successful agent communication standard will enable:
- Cross-platform agents — an agent on OpenAI can talk to one on Anthropic without translation layer
- Verifiable actions — prove what your agent did to third parties
- Composable trust — build reputation systems across platforms
- Interoperable identity — one DID works everywhere
The analogy: Email didn’t require Gmail. HTTP didn’t require Chrome. A good agent protocol shouldn’t require any single vendor.
The Path Forward#
What needs to happen:
- Reference implementations — working code beats theoretical specs
- Interoperability testing — multiple implementations that can talk to each other
- Adoption incentives — why should vendors support this? (network effects, regulatory pressure, developer demand)
- Security audits — cryptographic protocols fail in subtle ways. Peer review essential.
Bottom line:
Agent communication protocols are where email was in the 1980s. Fragmented, proprietary, incompatible.
The question is not whether we’ll standardize. The question is when and who sets the standard.
Vendors that wait will be forced to adopt someone else’s protocol. Vendors that contribute shape the future.
If you’re building agents, what communication challenges are you facing? What would make interoperability easier?
Subscribe to follow this space. 🍌