DEV Community

Calin Teodor
Calin Teodor

Posted on

I Built a True "Internet for AI Agents" in Pure Go – Permanent Addresses, Direct P2P, Zero Setup Hassle 🚀

#ai #go #networking #showdev

AI agents are becoming incredibly capable – reasoning, planning, tool use, and multi-agent collaboration in frameworks like AutoGen, CrewAI, LangGraph, and OpenClaw.

The missing piece? Reliable, direct connectivity across real-world networks. NATs, firewalls, and ephemeral environments make persistent, secure agent-to-agent communication harder than it should be – often forcing centralized relays or polling.

I built Pilot Protocol to fix that: a lightweight UDP overlay giving every agent a permanent virtual address, encrypted peer-to-peer tunnels, and simple trust controls.

Pure Go. Zero external dependencies. v1.0 just launched, already seeing real experiments and early traction.

Best of all: you can connect to a live demo agent right now and experience direct P2P yourself.

Repo: https://github.com/TeoSlayer/pilotprotocol

Try it out in ~5 Minutes

Here's the hands-on payoff first – install and connect to a running demo agent (agent-alpha):

# One-liner install (platform detection, binaries, optional system service)
curl -fsSL https://raw.githubusercontent.com/TeoSlayer/pilotprotocol/main/install.sh | sh

# Start your daemon
pilotctl daemon start --hostname my-devto-agent

# Handshake with the demo (auto-approved for testing)
pilotctl handshake agent-alpha "Dev.to reader saying hi 👋"

# Bridge to a local IP for normal tools
sudo pilotctl gateway start --ports 80 0:0000.0000.0004

# Visit the agent's site over an encrypted P2P tunnel
curl http://10.4.0.1/
# Or open in your browser: http://10.4.0.1/
Enter fullscreen mode Exit fullscreen mode

You just opened a direct, encrypted tunnel across the internet. No keys, no middleman servers.

More quick wins:

pilotctl ping agent-alpha          # Latency
pilotctl bench agent-alpha         # Throughput
pilotctl send-file agent-alpha ./data.json   # Direct transfer
Enter fullscreen mode Exit fullscreen mode

Pilot handles NAT traversal (hole-punching + fallback), encryption, and trust automatically. That's real reachability, today.

Why This Matters: An Agent-Native Network Layer

Agents need the basics the regular internet gave devices:

  • Permanent addresses that survive restarts/migrations
  • True inbound connections
  • Discovery and explicit trust
  • Standard ports for common patterns

Pilot delivers:

Highlights:

  • 48-bit virtual addresses + persisted Ed25519 identities
  • Well-known ports: 80=HTTP, 1000=stdio streams, 1001=framed file transfer, 1002=pub/sub events
  • Per-agent independence – dozens on one host, each with separate trust
  • Private-by-default mutual handshakes + instant revoke
  • Zero-config NAT handling
  • Gateway for curl/browser compatibility

Minimal by design – infrastructure for higher-level protocols (MCP, A2A, etc.) to run on.

Perfect Fit for OpenClaw Bots

If you're in the OpenClaw community, Pilot is especially powerful.

OpenClaw bots often run locally behind NATs on personal machines, handling privileged tasks across chat apps. Multi-instance or skill-sharing setups currently rely on centralized bridges or polling – adding latency and complexity.

With Pilot:

  • Bots get permanent addresses for direct dialing across NATs
  • Secure file/context sharing (port 1001), event coordination (port 1002), or interactive streams (port 1000)
  • Granular trust: explicit handshakes protect privileged access
  • Lightweight daemon integrates easily as a skill or sidecar

Turns distributed OpenClaw deployments into a true P2P swarm – faster, more private, resilient.

Quick Tech Overview

  • Reliable UDP transport (congestion control, SACK, segmentation)
  • Crypto: X25519 + AES-256-GCM streams
  • Local daemon over Unix socket – keeps agent code simple
  • Built-in services for instant utility

Core stable now. Nameserver and private topic networks next.

Comparison Note (Especially Tailscale)

Tailscale excels at device-level mesh VPNs.

Pilot's strength is per-agent granularity – lightweight, independent identities/trust without full WireGuard overhead. Complementary for many setups.

Let's Shape the Future

Pilot is early but already delivering real direct connectivity (as the demo shows).

Try the quick start above, build something, and share what you make.

What's one connectivity challenge you're hitting in your agent projects? Comment below – I'll reply to all and it feeds the roadmap.

⭐ Star if this resonates: https://github.com/TeoSlayer/pilotprotocol

Feedback, issues, and PRs very welcome!

Building the network agents deserve.

ai #golang #agents #p2p #opensource #networking #llm #autogen #crewai #langgraph #openclaw

Top comments (0)