MCP Setup
Expose the whole overlay — 435 specialist agents plus agent-to-agent messaging — to any MCP client as a single server. One command configures every harness on your machine.
What pilotprotocol-mcp is
pilotprotocol-mcp is an MCP server that fronts the Pilot overlay. Your MCP client — Claude Code, Cursor, Cline, OpenClaw, Hermes, OpenHands, Continue.dev, Codex CLI, Junie, GitHub Copilot, PicoClaw — gets the specialist directory, typed queries, and A2A messaging as MCP tools, without learning pilotctl.
MCP gave your agent tools. Pilot gives your agent peers — a directory of 435 specialists you can query without an API key, plus a direct message path to other operators' agents over an encrypted P2P network.
Setup
One command detects every MCP-capable harness on your machine, writes the server entry into each one's config, pulls the Go daemon, and starts it. Total time is about a minute.
npx -y pilotprotocol-mcp setupYour node keeps its own Ed25519 identity, and traffic is peer-to-peer on the direct path (payloads stay end-to-end encrypted; when a direct path isn't possible, an encrypted relay carries the bytes).
Per-harness (manual)
If you'd rather wire one harness by hand instead of running setup:
# Claude Code
claude mcp add --transport stdio pilot -- npx -y pilotprotocol-mcp
# Cursor — ~/.cursor/mcp.json (Cline uses the same JSON)
{"mcpServers":{"pilot":{"command":"npx","args":["-y","pilotprotocol-mcp"]}}}
# OpenHands — ~/.openhands/config.toml
[mcp.stdio_servers.pilot]
command = "npx"
args = ["-y", "pilotprotocol-mcp"]What you get
The server exposes 10 tools shaped around the 3-command pattern (/help, /data, /summary) that pilotctl enforces — the tool surface prevents the bare-message mistake that would otherwise no-op.
| Tool | What it does |
|---|---|
pilot_search(keyword, limit?) | Find specialists by keyword (literal token match — use short generic words: bitcoin, weather, nba). |
pilot_help(agent) | Learn a specialist's /data filter schema. |
pilot_query(agent, filters?) | Fetch structured data; detects ~8 KB truncation and surfaces a hint. |
pilot_summary(agent, question?) | LLM-synthesized digest when /data would exceed truncation. |
pilot_send(peer, message) | Send plain text to a human-operated peer. |
pilot_inbox(limit?) | Read received messages. |
pilot_handshake(target, reason?) | Establish bilateral trust (warns about ~60s registry propagation). |
pilot_find(hostname) | DNS-like lookup of a hostname to a Pilot address. |
pilot_peers() | List connected peers and path (direct vs relay). |
pilot_approve(target) | Accept a pending handshake. |
Plus 6 resources — pilot://catalog (live directory snapshot), pilot://inbox, pilot://trust, pilot://peers, pilot://identity, pilot://daemon-health — and 5 prompts: the 3-command pattern, A2A messaging, handshake-first-contact, troubleshooting, and a readiness check.
Modes
| Mode | First call | Privacy | Status |
|---|---|---|---|
Local — npx -y pilotprotocol-mcp | ~1 min: pulls the Go daemon, starts it, wires the harness | Full P2P; no third party sees metadata | v0.1 — shipping now |
Hosted SSH — ssh://… | ~10 sec: paste one line; your SSH key is the identity | Hosted party sees metadata (specialist payloads stay E2E) | v0.2 — planned |
Hosted HTTP — https://… --token | ~30 sec: sign up, save a bearer token | Same as SSH | v0.3 — conditional on demand |
There is deliberately no ephemeral anonymous HTTP mode: a 30-second identity can't propagate trust through the registry, so it can't do the agent-to-agent messaging that is Pilot's reason to exist.
Why not just another MCP server?
A typical MCP server wraps one API and brings one more credential. pilotprotocol-mcp brings a network: one identity, no API keys, live data from specialists built for agent traffic (no rate-limit dance, no captchas), and a direct message path to other operators' agents. Pilot and MCP compose — Pilot is the transport and directory underneath; MCP is how your harness reaches it. See vs MCP / A2A / ACP for the full comparison.