Two commands, and your editor has a fleet

The server is hosted by every host in the fleet, so there is nothing to run locally and no process to keep alive. The first command stores a token, the second writes the entry into whichever config file your agent reads.

any harness

$ pilot login$ pilot mcp install claude-codewrote ~/.claude.json (hosted)verify: /mcp, then ask it to list your machines

Or point any client at the URL

The endpoint speaks Streamable HTTP and takes an ordinary bearer token. A client with no token gets a login page in a browser instead, because the fleet answers with the document that says where to sign in.

Nothing runs on your machine

Every host serves the same endpoint from its own replica, so there is no gateway to be down and no single host your editor depends on.

The agents it knows by name

Each one takes the same command with a different argument, and writes the entry the way that agent wants it, merged with whatever is already in the file.

Claude Code

pilot mcp install claude-code

Or install the plugin, which adds the skill, two slash commands and a guard.

Codex

pilot mcp install codex

Writes the entry into config.toml and leaves every other line alone.

Cursor

pilot mcp install cursor

User-wide, or per repository with --project.

VS Code (Copilot)

pilot mcp install vscode

For Copilot. The pilots extension is separate and does more.

OpenCode

pilot mcp install opencode

Reads opencode.json, so the entry can live with the repository.

Windsurf

pilot mcp install windsurf

One user-wide file, no per-repository form.

Gemini CLI

pilot mcp install gemini

Settings live under .gemini, either scope.

Zed

pilot mcp install zed

Runs the server on stdio, which is where its context servers live.

Claude Desktop

pilot mcp install claude-desktop

Stdio, so the pilot binary has to be on the PATH it starts with.

Anything else

pilot mcp install generic

Writes an mcp.json you can paste into a client this list does not name.

Add --stdio to any of them to run the server locally instead, which adds the six tools that read your own files: deploy a directory, build one, push a file into a machine, pull one back out.

A plugin, where a plugin is better than a config line

Claude Code

$ /plugin marketplace add vivek7405/pilots$ /plugin install pilots@pilots$ /pilots:statusMCP tools: available

It carries the docs the model reads

A skill page per topic, so an agent asked to deploy something reads how before it guesses. The same pages the hosted server offers as resources.

It asks before it throws work away

A hook stops on a destroy, a restore, a rollback, and on a command that ought to be snapshotted first, and shows you the exact call before it runs.

Two commands you run yourself

/pilots:status checks the connection and changes nothing. /pilots:smoke takes the whole path end to end and asks before it cleans up after itself.

Cursor, Codex, Copilot and Kiro read the portable Agent Plugins (opens in a new tab) format, and the same directory ships that manifest too.

Typed clients, checked against the server

Each client keeps its own copy of the wire types, and each one has a test that parses the server's source and fails when the two disagree. A field the platform added cannot quietly go missing from a client.

TypeScript

npm i @pilots/sdk

Zero dependencies. Also ships the TanStack AI sandbox provider.

Python

pip install pilots-sdk

Two dependencies, and the framework adapters live here.

Go

go get github.com/vivek7405/pilots/sdks/go

One dependency, the same websocket library hostd speaks.

Elixir

{:pilots, "~> 0.1"}

One dependency. The HTTP calls go through OTP's own httpc.

python

$ from pilots import PilotsClient$ m = PilotsClient().machines.create(name="scratch")https://scratch.pilotrun.appthe same call, the same names, in all three

Moving from sprites.dev

The TypeScript and Python clients each ship a compatibility face that keeps the shapes a sprites codebase already calls, so the move is an import line rather than a rewrite. The streaming exec speaks the same byte protocol underneath.

Agent frameworks, already wired

If your agent is built on one of these, the sandbox is a dependency you install rather than an integration you write.

Google ADK

pip install 'pilots-sdk[adk]'

Seven tools, including a restore that refuses to run without a confirmation.

OpenAI Agents SDK

pip install 'pilots-sdk[openai-agents]'

A sandbox session per run, or one named machine that outlives them.

Claude Managed Agents

pip install 'pilots-sdk[anthropic]'

Anthropic runs the loop. Every tool call runs on a machine you own.

TanStack AI

npm i @pilots/sdk

A sandbox provider with snapshots, exposed through @pilots/sdk/tanstack.

A machine as a folder you are editing

The VS Code extension mounts a machine into your workspace, so opening, editing, saving and searching all happen inside it, with a shell in the same machine beside them.

command palette

$ pilots: Open Machinescratch  runningpilot://scratch/home/pilotedit, save, search. It is a folder now.

What an agent is allowed to do

Handing a token to something that writes its own commands is the part worth being careful about, so the consent screen asks the narrow questions and the fleet enforces the answers.

Only its own machines

A name prefix on the token. It can make and change what it named, and nothing else.

A ceiling on how many

A cap counted at create time, so a loop that forgets to clean up stops instead of spending.

An expiry, if you want one

Checked on every request beside the revocation check, from each host's own replica.

The token is an ordinary pilots token, which is the reason all of this is short. There is no second credential system to reason about, revoking one on the tokens page stops it everywhere, and it keeps working even when the dashboard that issued it does not.

Your agent, with a real computer