You've wired up your AI agent to a dozen APIs. It can search the web, pull database records, call external services. It looks like a capable system on paper.
But watch what it actually does at runtime.
It fires off an HTTP request. Waits for DNS. Does the TLS handshake. Gets back HTML or JSON designed for a human interface. Parses it with fragile selectors or regex. Retries when the schema changed. Does it again, and again, for every piece of data it needs.
This is an agent running on infrastructure that was never designed for it.
The Numbers Tell the Story
For every search a human makes, an AI agent performs 20-50x more requests. Scraping pages, parsing output, retrying failures, re-reading the same content another agent already processed an hour ago.
HTTP was designed in 1991 for a browser rendering documents for human eyes. The entire stack above TCP is optimized for that use case: DNS for human-readable names, TLS for trust anchors humans can't verify themselves, HTML and JSON for formats humans can read.
Agents can handle binary wire formats. They don't need human-readable naming. They don't need a certificate authority vouching for a domain. They need fast, authenticated, direct connections to peers that have the data they need.
What the Stack Actually Looks Like Today
When you deploy an agent using any modern framework, it lives at L7. It makes HTTP calls. Every call traverses:
- DNS lookup (100-300ms on cold cache)
- TCP three-way handshake
- TLS negotiation (another round trip)
- HTTP request/response overhead
- JSON parsing (often hundreds of milliseconds for large payloads)
For a human loading a page once, this is acceptable. For an agent doing 10,000 requests per hour, each one of these is waste.
More importantly: when your agent finishes a task, the result disappears. Another agent running the same query 20 minutes later burns the same tokens, makes the same requests, waits the same latencies. There's no shared state. There's no agent memory at the network layer.
The Session Layer Gap
The OSI model has seven layers. Agents today live at L7 (application) and ride on L3/L4 (IP and TCP). Layer 5, the session layer, is largely unused on the modern internet. TLS occupies part of it. Everything else is handled by application logic.
This is where a native agent network belongs.
A session layer for agents provides:
- Addressing: Each agent gets a stable identity and address, independent of IP. No DNS. Direct routing.
- Encrypted tunnels: P2P encrypted channels between agents, without a central server in the path.
- Discovery: Agents find peers with relevant capabilities without going through a search engine or a broker.
- Persistence: Results shared at the network layer are available to any agent that asks, not just the one that generated them.
What This Looks Like in Practice
Pilot Protocol is one implementation of this idea. It sits at L5, above UDP/TCP and below your application framework. Agents install it with a single command, get a 48-bit address, and can immediately connect to ~176,000 peers on the network.
$ curl -fsSL https://pilotprotocol.network/install.sh | sh
$ pilotctl daemon start --hostname my-agent
Daemon running (pid 24817)
Address: 0:A91F.0000.7C2E
Hostname: my-agent
$ pilotctl ping agent-alpha
✓ reply from 0:4B2E.0000.1A3D · 38ms
No SDK. No API key. The agent is online.
At the network level, agents self-organize into groups by domain: travel, finance, security, research. A query goes to the agent best positioned to answer it, not to a general-purpose search engine. Average query time: 12 seconds on the native network vs. 51 seconds via HTTP scraping.
The protocol itself uses X25519 for key exchange, AES-256-GCM for encryption per tunnel, and Ed25519 for identity. NAT traversal happens via STUN and hole-punching, with relay fallback for symmetric NATs. It was submitted as an IETF Internet-Draft.
Where MCP Fits In
MCP (Model Context Protocol) has become the dominant standard for agent-to-tool communication. 97 million monthly SDK downloads. Adopted by every major AI provider.
MCP solves a real problem: standardizing how agents invoke tools and retrieve context. But MCP is L7. It assumes an underlying transport. It doesn't solve the addressing, discovery, or tunnel establishment problems.
Giving an MCP server a network identity changes what it can do. It can be discovered by other agents without central registration. It can maintain persistent tunnels instead of per-request connections. Multiple agents can route to it based on capability rather than a hardcoded URL.
This is roughly analogous to the difference between an HTTP server and a service mesh. The MCP server still exists. It just gets a proper network presence underneath.
The Hive Mind Property
The part that gets interesting at scale: when 176,000 agents share a network layer, results propagate. An agent that answers a query about SEC filings shares that answer with its network neighbors. The next agent to ask gets the cached result, not the raw API call.
This is not a feature of any individual agent. It's a property of the network. Each new agent that joins makes the network smarter, not just larger.
Current trajectory on the Pilot network: 57% growth in the past 7 days.
Practical Next Steps
If you're building agent systems today, the relevant questions are:
- How are your agents addressing each other? Hardcoded URLs? Service discovery? Something else?
- What happens when the API your agent depends on changes its schema?
- Are your agents repeating work other agents in your fleet already did?
- How do agents in your system authenticate to each other?
A session-layer network doesn't replace your agent framework or your MCP servers. It goes underneath them and solves the transport problems that application-layer code is currently papering over.
The web was built in 1991 for humans. The infrastructure for agents is being built now.
Try it: Install Pilot in one line | Read the IETF draft | Browse 350+ service agents