Skip to content
pilots
Dashboard

Add Pilots to your agent

Two commands, then ask. Your agent deploys your app to production with nothing for you to configure, and it can open a sandbox, take a checkpoint and roll back too.

curl -fsSL https://pilots.run/install.sh | sh
pilot mcp install claude-code

Then ask for what you want

Say it the way you would say it to a colleague. Your agent knows the commands.

  • deploy this app

    It works out what the app needs, database and background jobs included, and hands you the live URL.

  • open a sandbox and run the tests

    A fresh computer, the command run in it, and the output back.

  • checkpoint before you upgrade

    A saved moment to return to if the upgrade goes wrong.

  • roll back the last deploy

    The previous version serving again, after asking you first.

  • run the CI of this repository on Pilots runners

    The repository enabled, a runner image built, and runs-on changed in the workflow.

Sign in once, then connect

The first command signs you in. The second adds Pilots to whichever agent you use, in that agent's own settings.

any harness
$ pilot login$ pilot mcp install claude-codewrote ~/.claude.jsonverify: /mcp, then ask: list my machines

Or point any client at the URL

Any MCP client works, and the address is all most of them get: an agent that has not signed in is sent to a sign-in page in your browser, and comes back with a token of its own, held to what you approved there.

Or let one command find them all

pilot setup finds the agents on your computer, adds Pilots and its skill to each, and checks that you are signed in.

Nothing runs on your laptop

Pilots hosts the server your agent talks to, so there is no process for you to start or keep alive.


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, /pilots:status, /pilots:smoke 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 in the editor. The Pilots extension is separate and does more.

GitHub Copilot CLI

pilot mcp install copilot

The terminal Copilot. One user-wide file under .copilot.

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

Reads the hosted server from settings.json, under context_servers.

Factory Droid

pilot mcp install droid

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

Antigravity

pilot mcp install antigravity

User-wide under .gemini/config, or per repository under .agents.

Pi

pilot mcp install pi

User-wide under .pi/agent, or per repository with --project.

Claude Desktop

pilot mcp install claude-desktop --stdio

Stdio only, 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 run the server on your own computer instead. That adds the tools that read your files, so your agent can deploy a project directly and move files in and out of a sandbox.

Run an agent inside a sandbox

Everything above drives a machine from the outside. Claude Code can also live in one and work on its own there, with every permission, because there is nothing of yours in it to wreck.

your terminal
$ pilot claude scratchpilot: installing Claude Code (once)...opens signed in as you, with no login in the sandbox

Signed in from your own computer

Your subscription token or API key stays beside your Pilots key on the computer you are typing at, and rides into the sandbox as the environment of one process. Nothing is saved in the sandbox, and nothing in it ever asks you to log in.

Yours to run, never an agent's

An agent asked to run it would carry the credential through its own context, so this one is a command you type. Any other agent runs in a sandbox through pilot exec, with whatever environment you hand it.

How the credential travels, where that stops, and what the sandbox gives the agent living in it: run an agent in a sandbox.

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

Claude Code
$ /plugin marketplace add pilotsrun/pilots-claude-plugin$ /plugin install pilots@pilots$ /pilots:statusMCP tools: available

It signs in the way you already did

The plugin uses the token pilot login stored. With none, run /mcp and it opens the same sign-in page in a browser. There is no key to paste and no variable to export.

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 skills you invoke 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

The same calls with the same names in every language. Each client is tested against the server itself, so one cannot fall out of step with it.

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/pilotsrun/pilots/sdks/go

One dependency, the same websocket library the platform uses.

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="my-app")$ print(m.url)https://my-app.pilotrun.appthe same call in all four, each in its own spelling

Or no client at all

Each one is a thin layer over the same HTTP API. Anything a client can do, a plain request with your key can do too.

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 computer that outlives them.

Claude Managed Agents

pip install 'pilots-sdk[anthropic]'

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

TanStack AI

npm i @pilots/sdk

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


A computer as a folder you are editing

The VS Code extension opens a computer as a folder in your editor. You open a file, change it and save, and it is saved on the computer, with a shell in the same place beside it.

my-app / app / page.ts
import { html } from '@webjsdev/core'export default function Home() {  return html`    <main>      <h1>Hello, World</h1>      <hello-counter></hello-counter>    </main>  `}
pilot://my-app/home/pilot saved on my-app

Run pilots: Open Machine from the command palette and pick a computer. The same works in Neovim.

What an agent is allowed to do

An agent writes its own commands, so you decide what its key may do when you make it. Pilots enforces the limits.

Only what it creates

A name prefix on the token. Everything it makes is named under the prefix, and it can act on and look inside only what is. The rest of the team it can see exists, and nothing more.

An expiry, if you want one

Checked on every request. A key past its date stops working everywhere.

A key can also be read-only: it can watch everything in the team, logs included, and change nothing. It cannot run commands or read files. Whichever it holds, an agent's key is an ordinary Pilots key. It can read its own grant back from the API, and revoking it on the tokens page stops it everywhere at once.