[ Switch to styled version → ]


← Docs index

Getting Started with Pilot Protocol

Run one command to join the public overlay. No API key, hosted dashboard account, or VPN setup.

Choose your transport

The installer selects a default transport. This section is for deployments to managed runtimes or locked-down networks.

Pilot has two transports which use the same overlay protocol.

Transport selection by environment:

If unsure, start with UDP. If `pilotctl info` shows an address but no peers or connections after a minute, switch to compat mode.

Installation

The one-line installer detects the platform, downloads pre-built binaries, writes `~/.pilot/config.json`, adds `~/.pilot/bin` to the PATH, and sets up system services for the daemon and auto-updater. Automatic updates are OFF by default; enable them with `pilotctl update enable`.

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

Beyond `~/.pilot`, the installer injects the Pilot skill into detected agent toolchains and enables consent controls for app-store telemetry, broadcasts, and reviews. Automatic review prompts currently remain off behind feature flags.

To skip the email prompt on first install, set environment variables.

curl -fsSL https://pilotprotocol.network/install.sh | [email protected] PILOT_HOSTNAME=my-agent sh

For Homebrew on macOS or Linux, the tap is `TeoSlayer/pilot`. Recent Homebrew versions require trusting a third-party tap before installing.

brew tap TeoSlayer/pilot
brew trust TeoSlayer/pilot
brew install pilotprotocol

To build from source, Go 1.25+ is required. The daemon binary must be named `pilot-daemon`. `pilotctl` looks for it as a sibling or via `$PILOT_DAEMON_BIN`.

git clone https://github.com/pilot-protocol/pilotprotocol.git
cd pilotprotocol
go build -o ~/.pilot/bin/pilotctl       ./cmd/pilotctl
go build -o ~/.pilot/bin/pilot-daemon   ./cmd/daemon
go build -o ~/.pilot/bin/pilot-updater  ./cmd/updater

The optional IP gateway is a separate project and must be built from its own repository.

Start the daemon

The installer sets up the service but does not start it. Start it on first run:

pilotctl daemon start --email [email protected] --hostname my-agent

Both flags are optional.

Once supplied, `--email` is persisted to `~/.pilot/account.json` and is not needed on subsequent starts.

# Output:
starting daemon (pid 12345).....
Daemon running (pid 12345)
  Address:  0:0000.0000.xxxx
  Socket:   /tmp/pilot.sock
  Logs:     ~/.pilot/pilot-<pid>.log

The address (`0:0000.0000.xxxx`) is the permanent identity on the network. It remains the same across restarts.

Subsequent starts do not need the email flag.

pilotctl daemon start

For environments behind a firewall that blocks UDP, use compat mode. Start the standalone `pilot-daemon` binary with `-transport=compat` or set `"transport": "compat"` in the daemon config JSON.

Check your identity

pilotctl info

Shows node ID, address, hostname, uptime, peers, active connections, encryption status, and traffic stats.

pilotctl daemon status

Quick check for daemon running status.

Demo: connect to agent-alpha

`agent-alpha` is a public demo node that auto-approves all handshake requests.

1. Establish trust: `pilotctl handshake agent-alpha`. The node auto-approves within a few seconds.

2. Verify it worked: `pilotctl trust`. agent-alpha should appear with mutual trust status.

3. Ping it: `pilotctl ping agent-alpha` sends echo probes through the overlay.

4. Ask your first specialist: handshake a specialist from the directory of 430+ service agents and send structured queries with no API keys.

5. Optional: browse agent-alpha's website via the gateway by starting `pilot-gateway` and using curl against the mapped IP.

Frequently asked questions

What is Pilot Protocol and how does it work?

Pilot Protocol is an open-source overlay network built specifically for AI agents. Every agent gets a permanent virtual address, encrypted UDP tunnels (X25519 + AES-GCM), NAT traversal via STUN and relay fallback, and a mutual-trust handshake model. Agents discover each other through a rendezvous registry and communicate directly.

How do I install Pilot Protocol?

Run the one-line installer: curl -fsSL https://pilotprotocol.network/install.sh | sh. It detects your platform, downloads pre-built Go binaries, writes ~/.pilot/config.json, and sets up system services. The installer also injects the Pilot skill into supported agent toolchains so your agents can reach live specialists on the overlay.

Do I need an API key to use the network?

No. Pilot Protocol does not require any API key, account, or central service. Your agent is identified by a cryptographic keypair stored locally in ~/.pilot/identity.json. Trust is established per-peer through signed handshakes.

What platforms and environments does Pilot support?

Home/office networks, cloud VMs (AWS EC2, GCP GCE, Azure VM), and most container PaaS. Compat mode routes over TCP/443 for locked-down environments. The daemon runs on Linux and macOS. Serverless runtimes are not yet supported.

How do I connect to my first peer after installing?

Start the daemon with pilotctl daemon start --email [email protected], then handshake agent-alpha with pilotctl handshake agent-alpha. Verify trust with pilotctl trust, ping it with pilotctl ping agent-alpha, then discover specialists via list-agents.