What Is an Overlay Network for AI Agents? (And What Pilot Protocol Is)

You've got agents that can call an LLM, run code, and search the web — but they can't call each other. Give two agents on different machines a way to talk and you'll hit the same four walls every time: no stable address, no way through NAT, no shared notion of who to trust, no way to find the other agent in the first place.

That's the problem the phrase "overlay network for AI agents" points at. And if you've been asking "what is Pilot Protocol, actually" — this is the answer.

What an overlay network actually is

An overlay network is a virtual network built on top of a physical one. Your agents keep their existing internet connections; the overlay adds a layer on top that gives each agent its own identity and lets them reach each other directly, regardless of where the underlying machines live.

You already use overlays daily — VPNs like Tailscale or WireGuard are overlay networks for machines. The difference here is the participant: instead of laptops and servers, the nodes are AI agents, and the network is designed around what agents need (persistent identity, programmatic access, no human in the loop).

The four walls every agent-to-agent setup hits

Addressing. If an agent's reachable address is its IP, it breaks the moment the machine reboots, the container migrates, or the cloud provider reassigns the public IP. Agents need an address that survives all of that — a name that follows the agent, not the machine.

NAT traversal. Most agents run behind home routers, office firewalls, or cloud NAT gateways. Two agents behind NAT can't open inbound connections to each other without help. The usual workaround — a central server both agents poll — adds latency and a single point of failure.

Trust. On the internet, "I can reach you" and "I trust you" are different questions. VPNs conflate them: join the network and you're trusted. Agents need a model where membership and trust are decoupled — you can be on the same network as another agent without automatically trusting it.

Discovery. Once agents have addresses and trust, how does one find another with a specific capability? You need a directory you can query by name or tag.

Every one of these is a solved problem for humans on the internet — DNS, port forwarding, TLS, search engines. The gap is that none of it is packaged for agents.

What Pilot Protocol is

Pilot Protocol is an open-source overlay network built for exactly this: it gives every agent a permanent virtual address that survives restarts, IP changes, and moves between clouds. Under the hood it's encrypted UDP tunnels — X25519 key exchange with AES-GCM — with reliability handled in userspace, so agents get a connection that behaves like a TCP stream without the NAT-breaking setup.

Three properties are worth calling out because they're the ones that usually surprise people:

It's not a VPN. The trust model is the big difference. Pilot uses explicit per-peer handshakes: two agents must mutually approve before they can talk. Joining the network doesn't grant trust — you decide per peer. That's the model agents actually need, where membership and trust are separate concerns.

NAT is handled, not worked around. STUN plus hole-punching, with a relay fallback when direct connection is impossible. Agents behind NAT are reachable — no port forwarding, no public IP requirement.

Discovery is built in. A rendezvous registry and nameserver let agents find each other by name or capability, the same way you'd look up a service in a directory.

It's written in Go with zero external dependencies, licensed AGPL-3.0, and the source lives at github.com/pilot-protocol. SDKs ship for Go, Python, Node, and Swift, and there's a plain-text version of the site at /plain — because the documentation is meant to be read by agents as much as by people.

The part that makes it more than a tunnel: the app store

An overlay network gives agents connectivity, but agents also need capabilities — search, databases, browser access, payment. That's where Pilot's app store comes in: installable apps that run locally on your daemon as typed IPC services, JSON in and JSON out, auto-spawned on install.

The loop is discover → install → call:

pilotctl appstore catalogue        # see what's available
pilotctl appstore install <id>     # install an app
pilotctl appstore call <id> <app>.method '<json>'   # use it

Apps are signature-verified (the manifest pins hashes, re-checked on every spawn), and permissions are grant-scoped — you accept them at install time rather than giving ambient authority. If you've built a tool or API that agents would want, you can publish it and let the network's agents discover it. "Bring your existing app or API; agents do the rest."

How it sits next to the other pieces you've heard of

One quick orientation, because the agent-tooling space has a lot of overlapping acronyms and they're not actually competing:

• MCP, A2A, ACP, ANP are application-layer protocols — they define how agents exchange messages or expose tools. They don't solve addressing, NAT, or transport.
• Tailscale, ZeroTier, Nebula are overlay networks for machines — they do solve the connectivity layer, but they're built for devices and humans, with trust models designed around joining a corporate or team network.
• Pilot Protocol sits at the transport layer for agents: an overlay network whose trust model is per-peer handshakes rather than network membership.

They compose rather than compete. You can run MCP on top of an overlay and get the best of both: a standard message shape and a transport where agents have stable addresses and can reach each other through NAT.

See it in two minutes

If you want to actually look at the thing rather than read about it, the whole install is one command:

curl -fsSL https://pilotprotocol.network/install.sh | sh

Then pilotctl gives you a node on the network — your own agent gets an address, and you can start handshaking with peers. The docs at pilotprotocol.network walk through the rest: addressing, tunnels, trust, and publishing an app.

The short version of "what is Pilot Protocol": it's the network layer your agents were missing — a permanent address, an encrypted tunnel that works through NAT, and a trust model where you decide who your agents talk to. The internet for agents, in the literal sense: an address, a connection, and a way to find each other.