The Agent Network Protocol (ANP) is an open-source communication standard designed to enable secure, decentralized communication between AI agents across the open internet. Often described as “the HTTP of the Agentic Web era,” ANP aims to build an open and efficient collaborative network for billions of agents while breaking down data silos and enabling autonomous agent organization.

Unlike centralized agent communication protocols that depend on platform-specific identity providers or API keys, ANP uses decentralized identifiers (DIDs) as the foundation for agent identity. This allows agents to autonomously control their identities without relying on any single authority, enabling permissionless agent discovery and networking across organizational boundaries.

The protocol is developed and maintained by an open-source community that has pledged never to commercialize it, ensuring an open and neutral foundation for the agentic web.

ANP employs a protocol stack with three distinct layers:

Implements decentralized authentication and end-to-end encryption based on W3C DID (Decentralized Identifier) standards. Agents authenticate each other without centralized certificate authorities or identity providers. Notably, ANP does not depend on blockchain — it leverages existing web infrastructure (HTTPS, DNS) for deployment and resolution.

Solves dynamic protocol negotiation by allowing agents to automatically negotiate which protocol format, version, and communication pattern to use. This enables heterogeneous agents built on different frameworks to interoperate without pre-agreed specifications.

Builds AI-friendly interfaces through the Agent Description Protocol (ADP) and discovery mechanisms. Agents expose their capabilities in structured, machine-readable formats that enable semantic search and automated service matching.

Agent-to-agent authentication in ANP follows a DID-based handshake:

1. Agent A initiates a connection request carrying its DID
2. Agent B resolves Agent A's DID document to obtain the public key
3. Agent B verifies the request signature using Agent A's public key
4. Agent B returns an access token
5. Agent A uses this token in all subsequent requests

This flow enables trustless, decentralized verification without any intermediary.

Resolving an agent's DID document and establishing a connection:

import requests
import json
from cryptography.hazmat.primitives.asymmetric import ed25519
 
AGENT_DID = "did:web:agent-b.example.com"
DID_RESOLUTION_URL = f"https://agent-b.example.com/.well-known/did.json"
 
# Resolve the target agent's DID document
did_doc = requests.get(DID_RESOLUTION_URL).json()
public_key = did_doc["verificationMethod"][0]["publicKeyMultibase"]
 
# Prepare signed connection request
my_private_key = ed25519.Ed25519PrivateKey.generate()
connection_request = {
    "from_did": "did:web:agent-a.example.com",
    "to_did": AGENT_DID,
    "purpose": "capability_query",
    "timestamp": "2026-03-24T12:00:00Z"
}
 
message = json.dumps(connection_request).encode()
signature = my_private_key.sign(message)
 
# Send authenticated request
response = requests.post(
    f"https://agent-b.example.com/anp/connect",
    json=connection_request,
    headers={"X-ANP-Signature": signature.hex()}
)
access_token = response.json()["access_token"]
print(f"Connected to {AGENT_DID}, token: {access_token[:16]}...")

ANP systematically addresses three fundamental problems in the agentic ecosystem:

• Agent Interconnection — Enabling all agents to connect regardless of developer, platform, or framework
• Data Silos and Context — Breaking barriers so agents can access complete contextual information across services
• Autonomous Organization — Using AI-driven negotiation and collaboration to form economically efficient agent networks

• Agent Network Protocol — Official Site
• W3C Community Group — AI Agent Protocol
• ANP Developer Guide
• ANP GitHub Repository
• arXiv:2508.00007 — Agent Network Protocol Specification

• Agent Communication Protocol (ACP)
• Agent-to-Agent Protocol (A2A)
• Decentralized Identity (DID)
• Multi-Agent Systems