Skip to content
pilots
Dashboard

What shipped

Release notes, newest first. Every entry here is the same text that cut the release it describes, so what shipped and what is written about it cannot drift apart.

v0.12.0

pilot

One command sets every coding agent on a machine up for pilots, and an agent no longer gets a copy of your login key.

Added

  • pilot setup: finds the coding agents on this computer, installs the pilots skill into each, registers the MCP server in each in the form it supports, and says last whether you are signed in. It asks once (-y for scripts), and a second run changes nothing. --agent, --skip-skills, --skip-mcp and --json narrow it. #448
  • pilot skill status, update and remove. pilot skill install now writes the skill to ~/.agents/skills/pilots and into each installed agent's own skills directory, not only Claude Code's. A copy you edited is left alone unless you pass --force. #448
  • pilot mcp remove <harness> takes the pilots entry out of an agent's config and leaves everything else in the file as it was. #448
  • GitHub Copilot CLI, Factory Droid, Antigravity and Pi are harnesses pilot mcp install and pilot setup know. #448
  • pilot key create --prefix and --expires mint a key held to the names it creates, or one that stops working after 24h, 7d or 30d. --scope read mints a key that watches a team and changes nothing. pilot key list and pilot whoami show a key's limits. #448
  • A failed call names its request. The CLI prints the id the fleet answered under, the value to quote when asking what happened. #448
  • pilot org domain puts every address of a team under a domain it owns. #419

Changed

  • pilot mcp install no longer writes your login key into an agent's config. For Claude Code, Codex, Cursor, OpenCode, Gemini CLI, Zed, Copilot CLI, Droid, Antigravity and Pi the entry is the URL alone: the agent signs in through your browser on first use and holds a token of its own, limited to what you choose on the consent screen. --key writes the old entry for a machine with no browser. VS Code and Windsurf keep the key-carrying entry. Run pilot setup or pilot mcp install <harness> again to switch an existing entry. #448

Fixed

  • pilot service info shows a replica the fleet is bringing back, with its attempts and last error. #443
  • Every CLI command reaches MCP, pilot repo connect works with an API key, and whoami and deploy name the team they act in. #434

v2026.11.06

platform

A token an agent holds is now held to what the person granted it, on every call.

Breaking

  • A token restricted to the names it creates is held to them on every call, not only when it creates. The consent screen has always offered to restrict an agent's token to things named mcp-…, and the fleet held it to that prefix only when the token chose a name. It could still run a command in, read the files of, roll back or destroy anything in its team. Now, outside its prefix, such a token sees that a thing exists and its state, and cannot act on it, look inside it or read its logs; the refusal is a 403 scope_required naming the prefix. A token with no restriction, which is every token pilot login or pilot key create mints, is unchanged. No token on the fleet carried a prefix when this shipped. #448

Added

  • A read-only token. The read scope sees everything in a team, logs included, and changes nothing: no create, no command, no deploy, no files. Mint one with pilot key create --scope read, from the tokens page, or on the consent screen. #448
  • An agent is shown only the tools its token can use. The hosted MCP server filters its tool list by the token's scopes, and init answers what the token was granted. A tool the token was not shown still answers with the route's own refusal. #448
  • Every answer names its request, as the X-Request-Id header and, on an error, as request_id in the body. #448
  • The consent screen asks the restriction as a choice: "only what it creates", chosen by default, or "everything in this team". The tokens page can now mint a token with a prefix and an expiry too. #448

Fixed

  • A restricted token's limits apply from its first request. A token used the moment it was minted could be served with no limits for as long as it took the host to hear about them. #448

v0.12.0

sdk-js

Every error names the request that caused it, and a key can read what it was granted.

Added

  • PilotsError.requestId: the id the fleet answered the request under, from the error body or the X-Request-Id header. Quote it when a call fails; it is the one value that finds the host's own line about that call. Empty from a fleet that predates it. #448
  • whoami() answers a key's limits: name_prefix, the prefix every name the key chooses or acts on must carry, and expires_at, the second it stops working. Both are absent for a key with neither. #448
  • The read scope, below machines, for a key that watches a team and changes nothing. Mint one with apiKeys.create({ scopes: ['read'] }). #448
  • A team's own domain: domains.team(), domains.setTeam() and domains.removeTeam() put every address of a team under a domain it owns. #419

Changed

  • A service keeps its size through an in-place redeploy, and its type says so. #414
  • A service's recovery attempts are on the service: the types carry the attempts and the last error of a replica the fleet is bringing back. #443

v0.11.0

pilot

GitHub Actions on your own machines, from the terminal.

Added

  • pilot runners: enable pilots runners for a repository, build the runner image for a size, and see the jobs running now. #403

Removed

  • Fallbacks for older fleets in pilot claude and pilot upgrade. Every fleet runs the current API. #405

v0.11.0

sdk-js

Run GitHub Actions jobs on your own machines from code, and one error class fewer.

Added

  • client.runners: list() shows the org's runner links, images and running jobs; link() enables pilots runners for a repository or an owner; buildImage({ size }) builds the runner image for a pilots-<N>cpu-<M>gb label. #403

Removed

  • QuotaExceededError. The fleet has had no per-account limits for some time and never sent it. A fleet with no room answers 507 no_capacity as a plain PilotsError. #405

v2026.10.07

platform

The fleet ships continuously, so this is the record of what changed rather than something to install. This entry is one idea: GitHub Actions jobs can run on pilots.

Added

  • pilots runners: GitHub Actions jobs on pilots machines. Install the pilots GitHub App, run pilot runner enable <owner/name>, and set runs-on: pilots in a workflow. Each job gets a machine of its own, forked from the team's runner image when the job is queued and deleted when it ends, so nothing waits warm between jobs. pilots is 2 vCPU and 8 GiB, the shape GitHub gives a private repository, and pilots-<N>cpu-<M>gb names any other size.

    Measured by hand on the production fleet on 2026-10-07: a runner machine is made from its image in about 1 s (median of five), and a job went from queued to started in 6 s (median of three), not counting the time GitHub takes to deliver the job. The first runner on a host that does not have the image yet takes about 70 s, once.

    The image is Ubuntu 24.04 with the Actions runner, git, Node 24, Bun, Go, Python 3, the GitHub CLI, Docker (with compose, buildx and service containers, all working inside the runner) and the Playwright browsers. It is built once per team, which takes minutes, and every job after that starts from it.

    A runner is an ordinary machine, billed by the second at the normal price, and the free allowance covers it. There is no separate price for CI. pilot runner usage shows runner time per repository. Everything is reachable from pilot runner and from MCP.

    No host coordinates it. The host GitHub's delivery reaches makes the runner, the host running it reaps it, and a once-a-minute reconciliation per repository catches a delivery that was lost. A job that cannot run on pilots says why on its commit.

  • A page for runners at pilots.run/runners, with the price per minute beside GitHub-hosted runners, Blacksmith and Depot, read from each one's pricing page.

Known limits

  • No nested virtualisation. A runner has no KVM device, so a job that boots a virtual machine of its own cannot run there.
  • No GPU, no arm64, no macOS and no Windows. Runners are x86-64 Linux, in one European region.
  • No cache storage of its own. actions/cache works through GitHub's cache as it does anywhere.
  • A team runs 10 jobs at once unless it sets another number with pilot runner enable --max.

v0.10.0

pilot

Added

  • a full host puts a start in line and answers busy with a retry time. #347
  • deploy a compose project, its database included, from the JS SDK. #335
  • services scale out across hosts up to a ceiling, and knobs change without a restart. #328

Fixed

  • builds are deleted only when no live chain reads them, and gone versions are never offered. #354
  • a Postgres recovers to a moment from the CLI, MCP and the SDKs, and a forked volume deploys anywhere. #334
  • a redeploy drops no requests, and a Postgres redeploy replays seconds of log, not a week. #327

Changed

  • Answer a fork at once with its names, and make it after. #353
  • Show a tenant no host id in any API answer. #351

v0.10.0

sdk-js

Fork without holding the request, and see no host ids. No call that worked on 0.9.0 changes.

Added

  • wait: false on a fork answers at once with the forks' names, state creating, and machines.waitFor(name) polls until each is running (or rejects when it ends in error). A dropped connection or a busy fleet no longer leaves a fork whose outcome nobody knows. #353

Changed

  • host_id is optional on machines, volumes, egress addresses, usage, whoami and health: the fleet now shows it to admin keys only. #351

v0.9.0

sdk-js

Publish an app with its own database from code, recover that database to a moment, and change a service's scaling without a restart. No call that worked on 0.8.0 changes, and every new field is an addition.

Added

  • compose.deploy() deploys a whole compose project from memory. Hand it the project as files (or a tar) and the values for its secret:// references; the fleet plans the compose file and every service is built, migrated (x-pilots.pre_deploy, once, on a throwaway machine made from the new build, before any replica is replaced), created or updated and rolled out in dependency order. A service whose inputs did not change keeps its release, and one whose only change is its scaling knobs has them applied in place. One service failing does not stop the others, and the result says what became of each. It is what pilot deploy does, without a disk or a binary. #335
  • compose.database('postgres') is pilot add postgres as values: the database and its pooler as compose services, its volume, the files its image needs, a generated password with the connection URLs made from it, and the environment the app sets (DATABASE_URL through the pooler, DATABASE_URL_DIRECT for migrations). Pass the same password on every later deploy. compose.recipe() is the raw fragment. #335
  • ExecStream.pipeStdin() streams a whole input into a command: a pg_dump into psql, sent in frames the far end accepts and paced on the socket, so a large dump is never one oversized message or held in memory whole. #335
  • Scaling knobs. max_machines_running caps how far a service scales out, hard_limit caps a replica's concurrency, and services.patch(id, { knobs }) changes any of them in place with no rebuild and no restart. Replicas now spread across hosts. #328
  • client.restorePostgres(service, { to }) recovers a Postgres to a moment as a new service beside the original, and volumes.snapshot, snapshots, forkSnapshot, restoreSnapshot, deleteSnapshot, policy and setPolicy cover a volume's snapshots and schedule. #334

Fixed

  • The SDKs read the host disk status the health check now reports. #313

v0.8.0

sdk-js

Give a machine a larger root disk. No call that worked on 0.7.0 changes, and every new field is an addition.

Added

  • disk_gib sizes a machine's root disk. Pass it to machines.create, machines.fork, checkpoints.fork and templates.fork for a root disk of that many GiB, up to MAX_DISK_GIB (64), instead of the image's 2 GiB. The filesystem already fills the disk when the call returns. A fork keeps its source's size unless it asks for more, and a smaller one is refused. You pay for the blocks a machine writes, never for the size of its disk. Machine.disk_gib reports the size a machine asked for; absent means the image's own. #309
  • machines.resize(id, { disk_gib }) grows an existing machine's disk. Unlike vcpus and mem_mib it is not a restart: a running machine's disk and filesystem grow with every process still running, and a sleeping machine's grow when it next wakes. A disk only grows. #309

v0.9.0

pilot

A machine can now have a larger root disk. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Added

  • --disk gives a machine a larger root disk. pilot machine create --disk 16GiB, pilot machine fork <machine> --disk 8GiB and pilot template fork <template> --disk 8GiB make a machine with a root disk of that size, up to 64 GiB, instead of the image's 2 GiB. The filesystem already fills the disk when the command returns. A fork keeps its source's size unless it asks for more, and it can never ask for less. You pay for the blocks the machine writes, never for the size of the disk. #309
  • pilot machine resize --disk grows an existing machine's disk. This is not a restart: a running machine's disk and filesystem grow while every process keeps running, and a sleeping machine's grow when it next wakes. A disk only grows. pilot machine info shows the disk size. #309
  • MCP: disk_gib on create_machine and fork, and a new resize_machine tool for vCPUs, memory and disk, which pilot mcp serves. #309

v0.4.0

sdk-js

Processes and files as first-class calls. Nothing that worked on 0.3.0 changes.

Added

  • machines.processes: detached, named processes you can come back to. start(id, { name, cmd, cwd, env, user, restart, keepAwake, stdout, stderr }) starts a process that outlives the connection and the client that started it, and survives suspend and wake, checkpoint and restore, and a fork. get, list, stop, start(id, name), restart, signal(id, name, 'TERM') (the whole process group by default) and remove manage it; get says whether it is running, restarting, exited, failed or stopped, with its exit code or signal. restart: 'on-failure' | 'always' brings it back, including after a cold boot. keepAwake: true keeps the machine from idling out while the process runs, for work nobody is watching; a dev server leaves it off and the machine still sleeps. env is held in the process's memory only, never on the machine's disk.
  • machines.processes.output(id, name, { offset, follow }): output you can replay. stdout and stderr are kept on the machine's disk (64 MiB per stream by default) and addressed by byte offset, so a reader that went away resumes exactly where it stopped. The iterator yields { type: 'data', offset, data } and ends with { type: 'end', offset, process }; a follow reconnects by itself when its connection breaks, for example when the machine suspends under it. outputLines(events) turns the events into text lines with their offsets.
  • machines.files: files as raw bytes. read, readText, readStream, stat, write (atomic, creates parent directories, mode as 0o644), list (recursive, with exclude globs such as node_modules), remove and archive (a streamed tar.gz of a directory). No more base64 through exec. A path is absolute or relative to the user's home.
  • A machine created before the fleet carried these APIs answers them with a PilotsError whose code is not_implemented: create a new machine, or deploy again, to get a guest agent that has them.

v0.8.1

pilot

A fix to 0.8.0's handling of a dropped connection. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Fixed

  • pilot deploy reports a failed build at once. In 0.8.0, a build that failed with an error mentioning a refused connection (for example, a build machine that would not start) was mistaken for a dropped connection: pilot deploy read its log again four times and then built it a second time before reporting the failure. A build that failed is now reported straight away. Only a build whose log stream ends with no result is followed again. #298

v0.7.0

sdk-js

Relabel a machine after it was made, and read what a release was deployed from. No call that worked on 0.6.0 changes, and every new field is an addition.

Added

  • machines.update(id, { labels }) relabels a machine. The labels MERGE: a value sets its key, '' removes it, and a key you do not name is kept, within the same limits as at create (32 labels, keys up to 64 bytes, values up to 256). Usage is recorded under a machine's labels as it accrues, so a relabel moves usage from that moment on and leaves what came before where it was: a machine handed from a pool to a customer is billed to each for exactly their share by usage.get({ groupBy: 'label:customer' }). url_auth can still be changed in the same call. #281
  • DeployRequest.source_digest and Release.source_digest. Pass any string that summarises what a deploy is built and configured from, and the fleet keeps it on the release that deploy cuts and returns it on every read of the release. Compare it with your next deploy's to skip a service that has not changed; pilot deploy does exactly that. The fleet stores it and never computes one, so a release cut by a push has none. #289

v0.8.0

pilot

pilot deploy now does what docker compose up does with a compose file: it deploys only the services you name, leaves a service running when nothing it is built from has changed, and keeps going when one service fails. It also rides out a host restarting in the middle of a deploy. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Added

  • Deploy only some services: pilot deploy . web, or pilot deploy web worker. Names after the directory deploy only those services of the compose file and leave every other one as it is. The first argument is the directory only when it is one, so pilot deploy ./api means what it always did. A name the compose file does not have is refused before anything is built, with the names it does have. The MCP deploy tool takes the same list as services. #292
  • A service that has not changed is kept running, not rebuilt and restarted. pilot deploy compares what each service is built and configured from (its files, its Dockerfile, its settings in the compose file and its secrets' values) with what its current release was deployed from. When they match, it keeps that release and prints unchanged, kept rel_..., so a database is no longer restarted because the web service beside it changed. --force (MCP: force) deploys it anyway. This needs the fleet to remember what each release was deployed from, which it does from today; a release deployed before that is deployed once more, and then kept. #292, #289

Changed

  • One failed service no longer stops the rest. Every other service in the compose file is still deployed, except one that depends on the service that failed: it is skipped, with the reason. The deploy ends with a table that gives each service's result (deployed, unchanged, failed or skipped) and release, and exits non-zero with each failure named and the command to deploy just those. --json rows carry status and error. A deploy of a single service that fails reads exactly as before. #292

Fixed

  • A deploy no longer fails with unexpected EOF when a host restarts during it. When the fleet is updated, its hosts restart one at a time, and a deploy that was going through the restarting host lost its connection and failed, even though the deploy itself could have finished. pilot deploy now checks what happened to the deploy and waits for it, or sends it again only if it never arrived, so the same build is never deployed twice. A build whose log stream drops the same way is followed again from its log instead of failing. #292, #288

v0.6.0

sdk-js

Usage and prices, for a platform that bills its own customers. Pilots now bills on usage alone (see pilots.run/pricing), and this release lets you read that usage, priced, from code. No call that worked on 0.5.0 changes, and every new field is an addition.

Added

  • usage.get works with any key, and reads the key's own org. It used to need an admin key. An admin key without an org still reads every org. #265
  • usage.get({ period }) reads one calendar month in UTC, like period: '2026-10', in place of since and until. #265
  • usage.get({ groupBy }). groupBy: 'machine' fills machines with each machine's usage. groupBy: 'label:<key>' fills groups with usage summed for each value of one label ('' holds machines without it). Label each machine with its customer and groupBy: 'label:customer' gives you each customer's bill. #265
  • usage.get({ fleet: true }) adds up every live host's numbers instead of only the host that answered. The answer's scope is 'fleet', and complete is false when a host did not answer, so the sums are short and worth asking again. #265
  • Every usage row carries its price. UsageTotals gains cost (cpu, memory, disk and total, in US dollars at list price, before the monthly free allowance), memory in gib_seconds, disk in disk_gb_months, and root_mib_seconds and snapshot_mib_seconds for what a machine's own disk and its checkpoints hold. #265
  • usage.pricing() returns the price list: the rates, the one-time trial credit, the monthly free_allowance, the reduced share for a young_account, and the minimum_charge_usd. It needs no key, so a platform can read the current numbers instead of copying them. #265, #276
  • New exported types: Pricing, UsageCost, and HoldRequest, HoldEntry and HoldsResponse for the admin endpoint that pauses an org's machines while it is on a billing hold. #265, #276

v0.7.0

pilot

Pilots now bills on usage alone, and this release brings the terminal and the MCP server up to date with it: see what a team has used and what it costs, add or remove a card, set a monthly budget, and break usage down by machine or by label. It also fixes custom domains set in a compose file, which never got a certificate. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Breaking

  • Plans are gone, so pilot billing activate and the MCP tool billing_activate are gone. There is no Free or Pro plan to choose any more. You pay for vCPU and memory only while a machine runs, and for disk whether it runs or sleeps, with no fee per machine and no limit on how many machines or apps a team has. To pay for usage beyond the free allowance, add a card with pilot billing card. #265
  • pilot billing --json has a new shape. It no longer has plans or status. It has the month's usage, its cost at list price, the bill after the free allowance, free_allowance, free_used and free_remaining, trial, card, budget_usd, hold, payment_due, rates and invoices. A script that read the old fields needs to change. #265
  • pilot usage asks the whole fleet and has new columns. It used to answer from one host only. It now adds up every host's numbers, and prints a note when a host did not answer and the sums are short; --host gives the old one-host answer. The columns are now VCPU-HOURS, GIB-HOURS, DISK GB-MONTHS and COST (at list price, before the free allowance), and rows are sorted by cost. #265

Added

  • pilot billing shows this month's usage and what it costs. One table gives CPU, memory and disk used, what is left of the free allowance, the cost at list price and the bill after the allowance. It also shows the trial credit left, the card on file, the budget, and the past months' invoices. If the team is on hold, it says why, says that nothing was deleted, and says what wakes the machines. #265, #276
  • pilot billing card opens a payment page in your browser to add a card, and waits until it is added. Card details go to that page, never through pilot. Adding a card also ends a hold caused by using up the free allowance. #265
  • pilot billing card remove (or pilot billing card --remove) takes the card off the team. What is owed so far this month beyond the free allowance is charged at once, and the team goes back to the free allowance. If it has already used the allowance, its machines go to sleep until a card is added or the month ends. It asks first; -y skips the question. #268
  • pilot billing budget <usd> sets the most a team may spend in a month, and --clear removes it. When the bill reaches the budget, the team's machines sleep until you raise it or the month ends. Nothing is deleted. #265
  • A failed payment shows in pilot billing. It gives the amount, the link to pay it, and the date the team's machines will be put to sleep if it is still unpaid: 7 days after the first failed attempt. #268
  • pilot usage --period 2026-10 reports one calendar month in UTC, in place of --since and --until. #265
  • pilot usage --group-by machine or --group-by label:<key>. Grouping by label adds up usage for each value of one label. A platform built on pilots can label each machine with its customer and bill each customer for exactly their machines with --group-by label:customer. --by-machine still works and means --group-by machine. #265
  • pilot billing mode <team> [standard|invoiced|internal] --note "why", for operators of a pilots fleet. It reads or sets how a team is billed; invoiced and internal teams are metered but never paused, and internal is never charged. It needs a key with the admin scope, and every change is recorded with who made it and the note. #268
  • New MCP tools: usage, billing_card, billing_card_remove, billing_budget and billing_mode, and billing now reports usage, cost, the free allowance and any hold. billing_card returns a link for the person to open, so a card never passes through the model, and billing_card_remove changes nothing until it is called with confirm: true. #265, #268

Fixed

  • A custom_domain in a compose file now gets a certificate. x-pilots: custom_domain used to reach only the service: pilot deploy printed the hostname as the service's URL, but every https connection to it was refused until you also ran pilot domain add. The deploy now attaches the domain itself. When the DNS record does not point at pilots yet, it prints the CNAME to set. If attaching fails, the deploy still succeeds and a note gives the command that finishes the job. #269

The free plan, in numbers

Every new person gets a one-time $5 trial credit, spent first, within 30 days of their first team. After that, each person gets 40 vCPU-hours, 80 GiB-hours of memory and 5 GB-months of disk free every month, shared by every team they own, with no card needed. A GitHub account under 30 days old gets a fifth of the trial and of the allowance. When a team without a card uses its share, its machines sleep until a card is added or the month ends; nothing is deleted. With a card, a month under $1 is not charged. The full price list is at pilots.run/pricing. #276

v0.6.0

pilot

This release lets you remove a service completely from the terminal, find things by label, and gives agents a way to add a database without the password ever reaching the model. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Added

  • pilot service delete <service>. Removes a service with every replica, its custom domains and its deploy history. --delete-volumes deletes its volumes too (otherwise they are kept, detached), and --ignore-not-found makes it safe to run twice in a script.
  • --label key=value on pilot service ls and pilot machine ls. The fleet filters, so a team with many machines gets back only the ones that match.
  • pilot volume destroy takes a volume's name, the same as every other command, instead of only its id.
  • pilot add --json, and an add_database MCP tool. An agent can add postgres, mysql, redis or mongo to a project: the password is generated and stored on your computer, and the tool's answer carries only a secret:// reference to it.
  • MCP tools delete_service and delete_volume, and labels and app filters on list_services.
  • pilot deploy --verbose streams every build line, including the ones normally hidden as BuildKit noise. It arrived in 0.5.0 and was missing from that release's notes.

v0.5.0

sdk-js

Deleting what you made, and finding it by label. Nothing that worked on 0.4.0 changes.

Added

  • services.delete(id, { deleteVolumes }). Removes a service and everything it owns in one call: every replica of every release, its custom domains, its releases and its deploy history. Its volumes are detached and kept unless deleteVolumes: true. It returns { id, deleted, machines, domains, volumes_deleted, volumes_kept } and is idempotent: a service that is already gone answers deleted: false, and a delete that stopped part way because a host did not answer (a 503) is finished by calling it again. #255
  • volumes.delete(id). Deletes a volume and every snapshot of it. Refused with a 409 while a machine has it attached; deleting the service that mounts it detaches it. #255
  • services.list({ labels }) and machines.list({ labels }). Only the objects carrying every label given, filtered by the fleet rather than in your process. #255
  • Build logs say why a deploy was refused, and hide BuildKit's noise. The deploy refused line of a build that carried deploy now has details, with details.replica and the replica's last console lines (secrets redacted). BuildKit's own warnings, cache import and export lines are tagged level: 'verbose' and left out unless you pass verbose: true to builds.create, builds.createFromRepo or builds.logs. #252

v0.5.0

pilot

This release gives a sandbox the pieces a product builds on: long-running processes you can come back to, files moved as raw bytes, templates that outlive the machine they came from, and private URLs a browser frame can open. It also fixes the team commands, which acted on your personal team whatever --org said. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Added

  • pilot process start | list | status | logs | output | signal | rm. Start a named process on a machine that keeps running after the command returns, then read its output from any byte offset or follow it live. Output is kept on the machine, so you can disconnect and pick up where you left off. A process can restart on failure, keep its machine awake, and survives suspend, wake and fork.
  • pilot file cat | ls | rm, and pilot file push | pull on the files API. Files move as raw bytes instead of through exec, so a large or binary file is no longer pushed as base64 in a command line.
  • pilot template create | list | info | delete | fork, and pilot machine create --template. A template keeps a machine's or a checkpoint's moment as a durable base. You can destroy the source machine straight after, rather than keeping a "golden" machine alive forever just to fork it.
  • pilot url token and pilot url revoke, and --auth token. A private machine can now be shown inside an iframe: token prints a short-lived URL that signs the browser in to that one machine, and revoke invalidates every outstanding one.
  • pilot machine fork --idle-timeout --label. A fork now keeps its source's idle timeout and labels (cron schedules excepted), and these flags override them.
  • A refused deploy says why. When the health gate refuses a release, pilot deploy shows which replica failed and the last lines of its console, with secrets redacted, and build logs no longer bury the build under BuildKit's own chatter.
  • MCP tools for all of the above: processes and files, template, templates, template_delete, preview_url, and idle_timeout and labels on fork.

Changed

  • Machines sleep two seconds after their last activity, not sixty, and a request that arrives during a suspend cancels it. --idle-timeout takes sub-second values from 500ms up to 1h. If you relied on a machine staying up for a minute between requests, set --idle-timeout explicitly.
  • No account caps. Nothing limits how many machines, vCPUs, volumes, builds or checkpoints a team holds, and pilot billing says so. A full fleet still answers no_capacity, and the message now says the fleet is out of room rather than pointing at your account.

Fixed

  • pilot billing, org, key and repo honour --org, PILOT_ORG, PILOT_API_KEY and --api-key. They read only the saved credentials, so pilot billing activate pro --org acme acted on your personal team. The MCP server's billing, team and key tools had the same bug under pilot mcp --org, and both are fixed.
  • pilot add postgres produces a database that boots. It edited compose.yaml even when pilot deploy reads compose.pilots.yaml, printed wrote %!s(int=N), and the database and its pooler ran as root and never passed their health gate. It now edits the file deploy reads (or --file), and --to makes the app wait for the database. Existing projects should re-run pilot add postgres.

v0.3.0

sdk-js

Templates and private preview links. Two removals follow the fleet: per-account quotas and the checkpoint field on a create, which hostd never read.

Breaking

  • quotas is gone. The fleet no longer enforces per-account caps on machines, resources, builds or checkpoints, so client.quotas.get/put, Quotas, QuotaResponse and QuotaExceededResponse are removed. A full host still refuses with no_capacity. #245
  • CreateMachineRequest.checkpoint is removed. hostd ignored it. To make machines from a checkpoint, call checkpoints.fork, or make a template from the checkpoint. #248

Added

  • Templates. templates.create({ name, from_machine | from_checkpoint, labels }) keeps a machine's or checkpoint's exact state as a durable base that outlives the machine. Make one, destroy the source, and make machines from the template for as long as it exists. machines.create({ template, name, env, labels, url_auth }) returns one machine. templates.fork(idOrName, { count, name, knobs, labels, env, secret_env, url_auth }) returns { forks }, the same shape as checkpoints.fork. templates.list({ labels }), .get and .delete complete the set, and a machine made from a template reports it in template. #248
  • Private preview links that work in an iframe. url_auth: 'token' gates a machine's URL on a short-lived signed token. machines.previewToken(id, { ttl_s, path, port }) returns { url, token, expires_at }. Load url in a frame: it sets a partitioned cookie for that machine's hostname, so every later request in the frame is authorized, live-reload WebSockets included. machines.revokePreviewTokens(id) revokes every link at once. #244
  • ForkRequest, ForkResponse, ForkEntry and UpdateMachineRequest are exported from the package root. 0.2.0 shipped the calls but left out the types. #248
  • ComposeProcess.image_entrypoint. It says whether a compose command: runs behind the image's ENTRYPOINT, as Docker runs it. #247

v0.2.0

sdk-js

Forking from JavaScript. Nothing that worked on 0.1.1 changes.

Added

  • machines.fork(id, req) and checkpoints.fork(id, req). Make new machines from a machine's or a checkpoint's exact state, processes running and memory warm, and get back { forks: [{ machine } | { error }] }, one entry per fork in the order asked for. Until now the types were there and the calls were not. #241
  • A fork can set its own lifecycle policy and labels. ForkRequest gains knobs, a partial policy such as { idle_timeout: 3600 }, and labels. Left out, a fork now keeps its source's knobs (all but cron schedules) and its source's labels; labels replaces them and {} clears them. #240
  • machines.update(id, { url_auth }). Switch a machine's URL between public and org after it was created. #241

v0.1.1

sdk-js

Packaging only. No API change, and nothing to do if you are already on 0.1.0 and not clicking links from the npm page.

Fixed

  • The npm page linked to a repository nobody can open. @pilots/sdk@0.1.0 names github.com/pilotsrun/pilots as its source, and that repository is private, so the "Repository" link on npm is a 404 for every reader. The link is gone and the page points at the API documentation instead. #193

v2026.09.23

platform

The fleet ships continuously, so this is the record of what changed rather than something to install. This entry is mostly one idea: the dashboard stopped being the only place some things could be done.

Added

  • Every operation is reachable without the dashboard. Thirteen things could only be done on a web page — setting up push-to-deploy, minting and revoking tokens, creating and renaming teams, inviting and removing people, handing a team over, changing a plan. All of them now work from pilot, from an agent through MCP, and are visible in pilot tui. The dashboard still does all of it; it is no longer the only way. #189

    The reason this was hard is worth recording. These are exactly the operations that turn on who you are and what role you hold, and the fleet API has no notion of either — a host knows a team as an opaque id and a key as a scope. The unlock was that a key minted by pilot login already recorded who approved it, so the dashboard can authenticate the person behind a terminal request and run the same code its own forms run. One implementation of each rule, reached from three surfaces.

  • The dashboard in the marketing site's design system, with the team as a menu in the header rather than a page you navigate to. #184
  • Two product principles, written down and enforced by tests. Every operation is reachable from the CLI and MCP, and the browser is for consent only — the GitHub App install screen, a payment page — opened by the CLI rather than something you go and find. And: a tenant is shown no host, and never asked to name one. A new dashboard action with no CLI command now fails CI by name.

Fixed

  • A machine's page no longer asks you to name a host. Resetting a stuck builder took a host id, which meant finding the one identifier the platform promises nothing about — your machine may be on a different host tomorrow. It names the builder now.
  • pilot claude no longer asks for a browser login every time it starts. #185
  • Installing and upgrading the CLI needs no account. #193

Known limits

  • Repositories owned by a GitHub organisation are not listed when you ask for the repositories you can deploy. They can still be connected by name. Listing them needs your own GitHub identity and a membership check, which the platform does not keep today.
  • The GitHub path has no end-to-end test. Connecting a repository and the App-install wait are covered by tests with GitHub stubbed; no test drives a real installation or a real push.

v0.4.0

pilot

This release is about not being sent to a web page. Setting up push-to-deploy, running a team, minting a token and changing a plan could only be done in the dashboard, so an agent holding the CLI could get you a URL and then had to stop and tell you to go and click something. All of it works from the terminal now, and from the MCP toolset an agent drives. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Added

  • pilot repo deploy acme/shop takes a repository to a URL with nothing checked out. It claims the repository for your team, opens the GitHub App install page and waits if the App is not on that account yet, creates the service, builds, releases, and wires push-to-deploy. One command, and the only thing you do is approve the GitHub screen.

    Connecting a repository could not be done from a terminal at all before this, by anyone without an admin key. The claim needed a service, creating a service from a repository needed a build, and a build needed the claim — a circle a normal key could not enter at any point.

  • pilot repo connect | disconnect | show | ls. connect writes both halves of push-to-deploy: your team's claim on the repository, and the service's branch. When the App is missing it opens the install page and waits, rather than printing a URL and asking you to run the command again — which was silent when you forgot, because the service looked wired up and no push ever arrived. ls shows the repositories you granted, so you pick one instead of remembering its exact name.
  • pilot org create | rename | delete | members | invite | remove | transfer | leave. Running a team from the terminal. Inviting a teammate carries no secret and needs no consent screen, and it needed a browser.
  • pilot key create | list | revoke, with --org to mint for a team you belong to. admin scope is still owner-only and still refused to anyone else, exactly as the consent screen refuses it.
  • pilot billing show | activate. A plan here is a set of limits the fleet holds your team to. When a payment provider is configured, activate opens its page and waits for the plan to actually move, rather than reporting success at a checkout you have not finished.
  • A repos tab in pilot tui, beside machines and services: which service deploys from which repository, and on which branch. It reads the same fleet snapshot the other two do, so the dashboard being unreachable cannot blank it — pilot tui talks to the fleet and nothing else.
  • Colour. States are green, amber or red the way the dashboard paints them, error: is red, and the next step is in the colour used for anything you are meant to type. It turns itself off when the output is not a terminal, under --json, under NO_COLOR and on a dumb terminal, so pilot machine ls | awk '{print $1}' is unchanged.
  • 22 new MCP tools for agents: repos, repo_claim, repo_connect, repo_disconnect, repo_deploy, teams, team_admin, keys, key_revoke, billing, billing_activate, service_set, domain_add, domain_remove, builders and more. An agent can now change a service, attach a domain and reset a builder, where before it could only read them.

    There is deliberately no tool that mints a token or sets a secret: the value would travel back through the conversation. Those stay commands you run.

Changed

  • pilot builder reset names a builder, not a host. It took a host id, which made you go and find the one identifier this product promises nothing about — a machine may be on a different host tomorrow. It now takes a builder id from pilot builder ls and finds the host itself. If you have this in a script, the argument changes.
  • pilot machine ls and pilot service ls show CREATED instead of ID. Every command takes a name and resolves it, so the id was a column nobody typed and everybody scrolled past; "3d ago" is the question you actually have in front of a list. Both fields are unchanged under --json, which is what a script reads.

Upgrading from 0.2.0 or 0.3.0, which `pilot upgrade` cannot do for you

If you are on 0.2.0 or 0.3.0, pilot upgrade will tell you no release has been published. It is wrong, and re-running it will not help. Those binaries ask GitHub about the repository the source used to live in, and that repository is now private, so GitHub answers "not found" and the CLI reports it as nothing having been published.

Install this one the way you first installed it, and pilot upgrade works from here on:

``sh curl -fsSL https://pilots.run/install.sh | sh # or npm install -g pilots@latest ``

Fixed

  • pilot upgrade will not move you backwards. It compared the published version against yours for *difference*, not order, so a binary ahead of the latest release — a prerelease, or one you built — was replaced by an older one and told upgraded pilot v0.4.0 -> v0.3.0. It now installs only what is newer, and --force is the way to go back on purpose.
  • pilot claude no longer asks for a browser login every time it starts. #185
  • Installing and upgrading works without an account. The install script and pilot upgrade fetch from a public location again, so neither needs credentials. #193
  • The npm page no longer promises provenance it does not carry. #195
  • A CLI newer than its fleet's dashboard says so. A team or token command against an older dashboard answered "the dashboard answered 404 / try again", which sent people to report a version difference as a bug and to retry the one thing that cannot start working. It now names the dashboard as older than your pilot.

Known limits

  • Repositories owned by a GitHub organisation are not listed by pilot repo ls. They connect by name, and everything else about them works.
  • The team, token, plan and repository commands need the fleet's dashboard to be current. They are the one part of the CLI that talks to it rather than to a host; pilot deploy and everything else keep working when it is down.

v0.3.0

pilot

This release makes signing in work. On 0.2.0 a pilot installed from the script or from npm could not authenticate at all, and pointed at a fleet on your own laptop: anyone who did not build the binary themselves was stopped at the first command. Upgrade with pilot upgrade, or npm install -g pilots@latest.

Fixed

  • pilot login works on an installed binary. It asked GitHub for a device code only when PILOT_GITHUB_CLIENT_ID was set in the environment, and nothing set it, so a user who installed the release was asked for an API key they had no way to obtain. The client id is now built in, and it is still overridable for a fleet that runs its own GitHub App.

    Login opens a browser where there is one to open. An SSH session, a CI job, or a machine with no display server prints the URL instead, because a browser that silently fails to appear is worse than the address you can copy.

  • A fresh install talks to the public fleet. The built-in default was http://api.pilots.localhost:8080, which is right for a single-box runbook and wrong for every installed copy: pilot login filed a key against an address with nothing behind it, and the first pilot deploy dialled a port on the user's own laptop. Every override still applies in the order it always had.
  • A failed deploy says what went wrong. The fleet has always carried the cause of a 500 in details.cause and every client dropped it, so a deploy that failed printed the category rather than the reason. It now prints the cause, which is usually one sentence naming the thing that did not answer.
  • A deploy recovers a cold image instead of failing. The first rollout of a brand-new image can time out waiting for the guest agent, and rebuilding produces a different image that is cold again. pilot deploy now deploys the same build a second time, which is warm, rather than leaving you to do it by hand.
  • pilot machine logs --tail exists. The agent skill's own table has answered "the end of a log, not the boot" with that flag for months while the command had only --follow. It does nothing under --follow, which starts from the end regardless, and the help says so.
  • Commands that were printed but never existed. machine show, service update, service url-auth, machine promote, machine restart, service rm, volume snapshots restore, tokens and env set were all named in help text, error hints or the agent skill, and each answered "unknown command" to anyone who followed the advice. So did pilot domain add --service web --hostname app.example.com, which takes two positional arguments, and pilot machine create --name scratch, where the name is positional. Every one of them now names a command you can run.
  • pilot mcp install prints the file it wrote the way you would type it, ~/.claude.json rather than an absolute path, and the verify hint it ends on is the one the harness table carries.

Added

  • Command groups are singular. pilot machine create, pilot service deploy, pilot volume ls, and the same for domain, secret, org, builder, process and session. Every plural is kept as an alias, so pilot machines ls and pilot svc deploy work exactly as before and nothing you have typed or scripted breaks. Only what the CLI says changed.
  • Checkpoints in the TUI. A machine's checkpoints are a screen of their own, and restoring one is a keystroke from there rather than a command you have to leave the dashboard to type.
  • Suspend and wake from the TUI's lists, on either tab. s and w used to reach a machine only through its detail screen, and did nothing at all on the services tab. On a service they now act on every replica at once rather than one after another, because a suspend uploads a memory image and eight in sequence is most of a minute of screen that looks dead. A partial failure says how many landed.

    A service held above zero by min_machines_running refuses instead of pretending: the autoscaler would wake it within a tick, which reads as a bug in the screen rather than as the floor doing its job.

  • A sign-in screen that asks one thing. The consent screen put a name prefix, a machine cap and an expiry in front of anyone running pilot login. They are the right questions for an agent that registered itself and noise for a person opening their own terminal, so they moved into a disclosure for whoever wants a scratch key with a cap.

Changed

  • The fleet's hosts are out of the CLI. No command names a host or says which one a machine landed on. No request path depends on a particular host and a machine may wake on a different one tomorrow, so a CLI that showed you one was teaching you to depend on the single thing the architecture does not promise.

Limits

  • There is still no way to delete a service. db ha disable used to tell you to run pilot service rm, which has never existed and has no route behind it; the note now says so and points at destroying the machines as what stops it costing anything.
  • Linux and macOS only, on both common processor families. WSL is Linux, so the install commands work there unchanged. What we operate has the rest.

v0.2.0

pilot

The first published release of pilot, the command line and terminal dashboard for Pilots, as one static Go binary. It succeeds the TypeScript CLI's 0.1 line, which was published as @pilots/cli and is now deprecated.

Added

  • Two ways to install. curl -fsSL https://pilots.run/install.sh | sh puts the binary in ~/.local/bin with no sudo. npm install -g pilots carries the binary for every supported system and runs no install script, and npx pilots deploy runs it with nothing installed. Both are on the install page.
  • The installer verifies, or installs nothing. The download is checked against the checksums.txt published beside it. A checksum that cannot be fetched, a missing line, a mismatch, or a machine with no sha256sum or shasum each stop the install before anything lands on your PATH.
  • pilot upgrade verifies too. The new binary is checked against the same file before it replaces the running one with a single rename, so an interrupted or tampered download leaves the old binary working. pilot upgrade --check only reports.

    A binary that npm or Homebrew installed is left to its manager: pilot upgrade and --check both print the command that upgrades it there.

  • One command line for sandboxes and services. pilot deploy takes a directory to a URL from a compose file, a Dockerfile, or neither. pilot machine, console, exec, file and proxy drive a sandbox, pilot promote turns one into a service without changing its URL, and service, logs, domain, secret and volume run it in production.
  • pilot tui. The fleet as a dashboard you leave open, from the same binary.
  • pilot mcp install <harness> connects Claude Code, Codex, Cursor and the other agents listed on the agents page to the fleet's hosted MCP server.

Limits

  • Linux and macOS, on x64 and arm64. There is no Windows build. WSL is Linux, so both installs work there unchanged, and on Windows itself the npm package says so and points at WSL.
  • A checksum proves the file you received is the file the release published. It is not a signature. The npm package carries a provenance record that ties it to the commit and the workflow run that built it.