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. One that has not signed in is sent to a sign-in page in your browser, and comes back connected.

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. 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

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

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

1import { html } from '@webjsdev/core'23export default function Home() {4  return html`5    <main>6      <h1>Hello, World</h1>7      <hello-counter></hello-counter>8    </main>9  `10}

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.

Its own names

A name prefix on the token. Everything it makes carries the prefix, and it cannot take a name outside it.

An expiry, if you want one

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

An agent's key is an ordinary Pilots key. Revoke it on the tokens page and it stops working everywhere at once.

Add Pilots to your agent