Linked machines
Each machine runs its own Overdeck and owns its own conversations, agents and credentials. A machine link lets one machine’s dashboard reach another machine’s dashboard: the two servers talk to each other over an end-to-end encrypted channel, so this machine can show and control what runs on the other one. Your browser still talks only to the machine it opened. Released in v0.73.0. A link is one direction. Link both ways (the default) creates the mirror link in the same step, so either dashboard can show both machines.Link a machine
On the machine you want to reach, create a pairing link, exactly as for a device:https://desk.tailnet.ts.net/#pair=odp_… and works once, for ten minutes.
On the machine that should reach it, paste the link:
pan machines link --one-way
is the CLI form of unticking Link both ways.
Both servers on one host (for a test) need --allow-loopback, because a localhost
pairing link only works on the machine that printed it.
An agent can ask you for a link. Its link_machine tool shows a Machine link
requested card in Needs you and at the top of the agent’s conversation. In a
browser on this machine, the card’s Link a machine… button opens this dialog. After
the link succeeds, the agent learns the new machine’s label, never the pairing link. See
Machine links.
SSH machines
A machine that this one reaches only over SSH (a VPS, a lab box behind a bastion) can be linked without running anything there by hand. Use Settings → Anywhere → Machines → Add an SSH machine (also the command palette’s Add an SSH machine), or:~/.ssh/config,
so it works from any browser that can open this dashboard:
- It opens an SSH session to the host.
- It checks that the host has the same
panversion as this machine. - It adopts the Overdeck dashboard already running there, or starts one with
pan up. - It forwards a loopback port on this machine to the host’s dashboard port.
- It pairs over that forwarded port and saves a machine link whose route has kind
ssh.
pan machines test-ssh <host>) runs only steps 1 and 2: it
connects over SSH and compares the pan versions. The host field
suggests the concrete Host aliases of this machine’s ~/.ssh/config.
The dialog has no access-level choice; the CLI does: pan machines add-ssh --agent-fenced
and --one-way.
To set a server up from the server itself instead (a lasting service that survives
logout and reboot), use Link a fresh server.
Requirements
- OpenSSH (
ssh) on this machine, on the dashboard’sPATH. - A key or SSH agent the dashboard process can use without a prompt. Every call uses
BatchMode=yes. If your keys live in an agent, start the dashboard (pan up) from a shell that hasSSH_AUTH_SOCKset. - The host key already in
~/.ssh/known_hosts. Overdeck never accepts a new or changed key for you: runssh <host>once in a terminal on this machine and check the key. - The same
panversion on the host. A different version fails withversion-mismatch, which names both versions and the command to run there,npm install -g @overdeck/core@<this version>. Nothing is installed for you. Whenpanis not on the host’s loginPATH, give its absolute path under Advanced (--pan-path).
Started by Overdeck, or already running
The row of an SSH machine showsSSH <host> · forward <state> · <launch>:
- Started by Overdeck (
managed): this machine ranpan upon the host. Removing the machine stops that server, unless you tick Leave the server running (pan machines unlink <machine> --keep-server). - Already running (
external): the host’s server was running before. Removing the machine never stops it.
pan up runs next to it (the
supervisor would otherwise restart the dashboard). Other sidecars that pan up started on
the host (CLIProxy) keep running. If the host’s supervisor cannot be stopped (on a Mac, the
launchd agent that pan connect installs), the server is left running. A server is also
left running when another machine holds an active link to it (in-use), or when it was
restarted since this machine started it.
The forward
This dashboard keeps the SSH port forward running while it runs: it starts it at boot, restarts it with back-off (1 s doubling to 60 s) when it exits, and moves it to another local port when its port is taken. When SSH refuses the login or the host key, the forward stops retrying and the row shows forward attention with the reason. Fix the key or the host key, then press Reconnect, which restarts the forward and starts or adopts the host’s server again.Link a fresh server
To link a server you reach over SSH, one command on the server does everything: it installs Overdeck as a service that survives logout and reboot, starts it, and prints the link.pan machines link '…' line it prints on your laptop. See
pan connect for lingering, macOS, firewalls and removal.
Running
npx @overdeck/core connect as a systemd service on a fresh VPS has not yet
been tested end to end on a real VPS (#4863).Fly machines
A Fly machine is a Fly.io VM that runs Overdeck (pan serve) and is
linked one way from this machine over wss://<app>.fly.dev. Everything between the two
travels inside the same end-to-end encrypted channel as any other link; Fly’s proxy sees
only ciphertext. Use it to run a conversation on a fresh machine without tying up this one:
--message above.
This one command, which takes a few minutes:
- Starts a Fly VM from the
pan-workspaceimage and makes itspanversion equal this machine’s. - Copies your Claude, Codex (when this machine has a Codex sign-in) and GitHub credentials to it (no SSH key ever reaches the VM).
- Starts Overdeck there and links to it. Its chip reads
fly-<machineId>. The Fly machine advertises no private addresses, so this machine reaches it only overwss://<app>.fly.dev. - With
--project, clones that project onto the VM (GitHub projects only). - With
--message(which needs--project), starts a Claude Code or Codex conversation (--harness) there and prints its URL.
pan machines add-fly also takes --region (default remote.fly.region, else iad),
--image (default registry.fly.io/<app>:latest) and --effort, which the page does not
otherwise name; see pan machines add-fly.
The conversation then streams in this dashboard like any linked conversation: use
Remote control to steer it, or Pull here to bring it home.
Setup
Fly machines use the[remote] and [remote.fly] settings, which pan start --remote
also uses to start work agents on Fly:
-
enabled = trueunder[remote]in~/.overdeck/config.toml:remote.enabledlives only in config.toml. The global~/.overdeck/config.yamlalso has aremote:section, but it holds onlyresiliency_tierandmax_concurrent_agents; anenabledkey there does nothing, andpan admin config set remote.enabled <value>refuses rather than write it. In the dashboard, Settings → Anywhere → Machines → Add a Fly machine shows a “Remote is off” notice with a Turn on remote button that writes the[remote] enabled = trueline for you. -
A Fly token:
fly auth login, orFLY_API_TOKEN(or the variable that[remote.fly] api_token_envnames).fly auth login’s stored login works, but Overdeck only refreshes it throughflyctlafter a rejected request (PAN-4748), so a host where nobody runsflyinteractively should export a long-lived token instead:fly tokens create deploy -a <app>intoFLY_API_TOKEN. -
Once per Fly app, give it public IPs, because
https://<app>.fly.devneeds them and the Machines API cannot allocate them:
[remote.fly] vm_memory, raised to 2048 when
lower).
Lifetime and cost
A Fly machine is destroyed, never stopped, because a Fly VM loses its disk when it stops. That happens when:- you unlink it (
pan machines unlink fly-<machineId>). With--keep-serverit is not destroyed at once, but nothing heartbeats it any more, so it stops itself within about 5 minutes; - no linked conversation on it has been active for
[remote.fly] machine_idle_minutes(default 30; 0 turns the idle check off); - this machine stops sending its heartbeat for 5 minutes (the VM stops itself, and this machine destroys it once it sees it stopped).
remote.max_concurrent_agents, the same cap as remote work
agents; add-fly refuses with cap-reached when it is full (0 or unset means no cap).
Work agents on Fly
pan start <id> --remote, or pan start <id> --machine fly, starts the issue’s work agent
on a new Fly machine:
- The command pushes the feature branch, then asks the running dashboard to start a Fly
machine with the project, add the issue’s worktree there and start the work agent as a
conversation in it. It waits 5 to 15 minutes and prints the conversation’s URL. It needs
pan up. - The transcript streams in this dashboard while the agent works, with the
fly-<machineId>chip. The issue’s row in the project tree lists the conversation and opens it. pan tell <id>,pan kill <id>and the dashboard’s output view reach the agent’s session on the Fly machine.- When the agent finishes and touches its done marker, the reap hands the branch to review here, then destroys the Fly machine. While the agent works, the idle sweep leaves the machine alone.
- Pull here is not for work agents: pulling the conversation home stops the agent from continuing, and the reap will not hand it to review.
- Claude Code with an Anthropic model only; Codex is not supported as a Fly work agent. The
durable tier (
--tier durable, orremote.resiliency_tier = "durable") is refused. - An issue that still has a remote workspace from before this change is refused; destroy
it with
pan workspace destroy <id>first.
Codex
--harness codex starts a Codex conversation on the Fly machine instead of a Claude Code
one:
- It needs
--modelwith an OpenAI model id. There is no default model. - This machine needs the Codex CLI and a Codex sign-in (
codex login).add-flychecks both, and the model, before it starts a VM. - The VM’s Codex CLI is pinned to this machine’s version.
- Codex on the VM calls OpenAI directly with your sign-in. It does not use CLIProxy.
- OpenAI replaces your refresh token each time Codex refreshes its sign-in, so two copies of one sign-in cannot both stay valid. Every 60 seconds this machine compares its sign-in with each Fly machine’s, and the newest refresh wins: a newer refresh on the VM is copied here, otherwise this machine’s sign-in is copied to the VM.
- If both machines refresh inside the same minute, one of them can be signed out. Run
codex loginhere; the next sync copies the new sign-in to the VM.
--harness you pass, so
a Fly machine started for Claude Code can also run a Codex conversation later.
add-fly prints codex: yes for such a machine.
Limits
- Claude Code and Codex. Other harnesses cannot run on a Fly machine.
- Codex runs with its usual
workspace-writesandbox on a Fly machine; shell commands work there (checked live, PAN-4296). - Docker: the VM runs Docker with the
vfsstorage driver, because the VM’s disk cannot host the default overlay driver. Containers run, but images take more disk and start more slowly than on your own machine.add-fly --jsonreportsrecord.dockerastrueorfalsefor each machine.
Gauntlet lanes
A linked Fly machine runs gauntlet lanes like any linked machine: name it withpan lane start --machine fly-<machineId>, or let --machine auto --needs docker choose
it. It runs Claude Code and Codex lanes only. A run with long waits between reports can sit idle
longer than machine_idle_minutes, so raise it for that run. See
Lanes on other machines.
Access levels
Neither level can pair devices, mint tokens or change the other machine’s settings. The
other machine refuses those routes to any linked machine.
What is encrypted
Everything, on every route. The channel is a Noise protocol session (X25519, ChaCha20-Poly1305) between the two machine keys; the pairing code only introduces the keys. Every request, the event stream and every terminal that crosses a link runs inside the channel. A machine’s key lives in~/.overdeck/machine-key.json, mode 0600, and its
fingerprint (five groups of four hex characters) is printed for each link by
pan machines list and shown on each Inbound row in Settings → Anywhere → Machines,
so you can compare it with the other machine’s This machine line.
Routes
A link keeps a list of ways to reach the other machine, best first: a LAN address, a Tailscale address, an SSH forward, then public or relayed ones. Where they come from:- The pairing address is the one in the pairing link.
- Advertised addresses are learned from the other machine itself: its LAN and Tailscale addresses, and its Tailscale Serve name when it has one. When a better one answers, the link moves to it within a minute. Addresses the other machine stops advertising are dropped.
- An
sshroute is the forwarded loopback port (tcp://127.0.0.1:<port>) that this dashboard keeps open for an SSH machine. When the host also advertises a LAN or Tailscale address that answers from here, the link moves to it, and the forward stays as the fallback. - Add route (in the expanded route list) adds an address you know works. For a machine you reach over SSH, use Add an SSH machine instead of forwarding a port by hand.
pan machines join), then approve on the other
machine after checking that both screens show the same six-digit code. The full CLI verb
set is directory, join, accept, reject, approve and forget; see
the CLI page. The directory also adds
direct routes (rtc://<environment id>, a peer-to-peer WebRTC path) and, on the relay plan
(paid plans are invite-only for now), relay routes (rtc+turn://<environment id>, through a
TURN relay). The relay tries the TURN server over TLS on port 443 first, so a network that
blocks UDP can still reach it. This TCP fallback is covered by tests but has not yet connected
on a live Fly VM. These routes are tried only when
no LAN, Tailscale, SSH or public route answers, appear with the source directory, and are
never saved with the link. See
Find your machines through overdeck.ai.
States
On a Mac, a route stuck in Offline can say “macOS is blocking local network access for
Overdeck. Open System Settings → Privacy & Security → Local Network and turn on node
(<path>).” instead of the raw connection error. The dashboard only shows this when two
signals agree:
every LAN route to the peer failed with the same
EHOSTUNREACH errno, and a probe of this
process’s own network access confirms macOS denied it. A powered-off peer, which also fails
fast with EHOSTUNREACH, keeps the raw error instead, since turning on Local Network access
would not help there.
When a link drops, the row says why. froze means the other dashboard’s event loop
stalled (it reports its own stalls in the next heartbeat, so a frozen machine is told
apart from a dead network); network means nothing arrived.
Each row in Settings → Anywhere → Machines shows the machine’s name and state, then
two lines: the route in use and the access level, then the machine’s Overdeck version,
last heartbeat, load and tags.
When a link does not open
The dashboard always logs each WebRTC offer it receives and what it did with it, each directory connection change and each refused secure channel. For the full detail, setOVERDECK_ANYWHERE_DEBUG=1 in the dashboard’s environment and restart it. Then read the
[anywhere] lines in ~/.overdeck/logs/dashboard.log. The debug flag adds the routine lines:
ICE candidates, every signal frame from the directory, and channels that closed or timed out
during the handshake.
A phone that changes network (Wi-Fi to cellular, or a cell handover) keeps its link: after 2
seconds without a path it restarts ICE on the same connection, and the dashboard logs
rtc session <id> ice restart from <phone> instead of replacing the session. Messages typed while
the link was down show “Waiting to send” and send as soon as it recovers.
Sharing conversations
Once two machines are linked, each lists the other’s conversations next to its own. Sharing is on by default. A linked machine sees the metadata of every local, unarchived conversation on this machine: its name, title, harness, model, status, whether it is working, its last activity, project, git origin, working directory and issue. It never receives transcript content until you open a conversation, and then only that conversation’s newest page. Turn Share my conversations off in Settings → Anywhere → Machines to stop sharing. Linked machines drop this machine’s conversations on their next sync, within about 15 seconds. To hide one machine’s conversations without unlinking it, open the ⋮ menu on one of its rows and choose Hide this machine. The list footer then reads “<machine> conversations hidden · Show”; Show brings them back. A conversation appears once, however many machines list it: this machine’s own row wins over a linked row, and a linked row wins over its Session Vault saved copy (the row then offers the saved copy itself). A linked conversation with no title, or a title that is only a file path (such as an attachment path), shows as “New conversation” rather than that path or its owner’s list name.Title-bar states
The conversation title bar shows which machine runs the conversation. These are surface tones, never status colors.
In the three non-live states the composer is read-only and the conversation cannot be
renamed.
Machine chips, in the title bar and on conversation rows, drop the
.local suffix macOS
adds to hostnames (studio-mbp.local shows as “on studio-mbp”); hover a chip for the full name.
Remote control
Open a linked conversation from the list, or at/conv/@<environment-id>/<name>, or on
the phone at /m?conversation=@<environment-id>/<name>. Its
transcript streams live through this machine’s server, and you can send, answer
questions and approvals, stop, abort, switch model, compact and open its terminal, as if
it were local. Images load from the owner. The owner’s own access rules decide what is
allowed: an agent-fenced link, and an agent on a linked machine, can read but not
change the other machine’s conversations (agent-fenced). The one exception is work this
machine started there, which it may message and stop (see
Start work on another machine).
From the CLI, pan tell @<machine>/<conv> "<message>" delivers to a conversation on a
linked machine (see pan tell).
Pull here
Pull here (orpan conv pull @<machine>/<conv>) makes this machine the owner. A
conversation runs on one machine at a time. The pull has four steps:
- Release. The owner settles the conversation, with its uncommitted and unpushed
code changes, and stops its harness. If a turn is running you choose Wait for this
turn (up to 30 minutes) or Stop it now (
pan conv pull --stop-turnis the CLI form of stopping a running turn instead of waiting for it). - Transfer. The settled conversation crosses the encrypted channel.
- Adopt. This machine continues it in its own checkout and resumes the harness. It keeps the title it had on the owner.
- Finish. The old copy shows “Continued on <this machine>” and is read-only.
pan conv reclaim <conv>: it refuses while that machine
still runs it, and when that machine cannot be asked unless you pass --force.
Pull here works for Claude Code and Codex conversations.
Open preview
Preview in a remote conversation’s title bar forwards a TCP port from the owner to127.0.0.1 on this machine and opens it in a new tab, for a dev server’s preview. It
lists the ports Overdeck assigned to the conversation’s workspace and the project’s
service ports; you can type any other port. The CLI is
pan machines forward.
A forward reaches only 127.0.0.1 on the owner. Ports below 1024 or above 65535, and
Overdeck’s own ports (the dashboard and its API, the supervisor, 80, 443 and Traefik’s
dashboard port) are refused with port-refused. A forward closes when you stop it, when
the link goes away, or after 30 minutes with no open connection. It needs an
operator-level link.
Escape closes the Preview popover. A running forward keeps running until you stop it:
Escape never stops it.
Open in editor
On a linked conversation, Open in editor opens the owner’s checkout in your local editor over remote SSH:code --remote ssh-remote+<authority> <cwd>. For a machine added
as an SSH machine, the host is the destination you added it with (for example
ssh-remote+root@build-box), never the local port forward; otherwise it’s the link’s
Tailscale (tailnet) host name. A link with neither cannot do this (no-ssh-host). A
destination with a port, an IPv6 address or an uppercase letter is passed in Remote-SSH’s
encoded form (hex of {"hostName","user","port"}), so the command line shows a long hex
string. VS Code, VS Code Insiders and VSCodium are supported. Cursor and Windsurf are
shown disabled: their remote-SSH launch could not be verified.
Fleet versions and Update all
Settings → Anywhere → Fleet versions (orpan machines versions) shows one row per
machine, this machine first: the Overdeck version and the version of each harness CLI
installed there (Claude Code, Codex CLI, Kimi Code CLI, OpenCode, Grok Build, Muse Code,
Prime Agent, OhMyPi, Pi). A linked machine that is not online shows its last known Overdeck
version. A
linked machine on an Overdeck from before fleet updates shows the version to install and
its command.
Update all (or pan machines update) asks every online machine to update itself:
- Wait for running turns. Each machine waits until no agent or conversation is in the
middle of a turn there, checking every 5 s. It never starts on its own while a turn
works. After 30 minutes the row says it is still waiting. Update now on that row
(or
pan machines update --now) starts it at once; Cancel (orpan machines update --cancel) stops a waiting update. - Update each harness CLI with its own command. A CLI installed with npm is updated with npm into the same prefix. A failure in one CLI does not stop the next; the row shows the command’s output.
- Update Overdeck last on a machine where it was installed with
npm install -g @overdeck/coreor set up withpan connect(the update goes into~/.overdeck/runtimewithnpm install --prefix, nosudo), then restart that machine’s dashboard. A repository checkout (pan reloaddeployments) or the desktop app keeps its Overdeck and still updates the CLIs.
before → after once it changed. Update all always installs the
latest version; it never lets anyone pick a version.
Homebrew installs, Windows, and an npm prefix Overdeck cannot write show the command to
run yourself instead of running it. Offline, connecting, unsupported and revoked machines
are skipped, and so is a machine reached over an agent-fenced link: Update all needs an
operator-level link.
Start work on another machine
The new-conversation dialog has a Machine field: This machine (the default), Auto, each online linked machine by label, and Fly (new VM). Fly (new VM) is enabled once the dialog has a project (it needs one to clone) and needs an admin credential; choosing it starts a new Fly machine, clones the project, runs the conversation there and takes a few minutes: the dialog shows “Starting a Fly machine.” while it works. The machine is destroyed, like any Fly machine, once no conversation on it has been active for[remote.fly] machine_idle_minutes (see Lifetime and cost). The
CLI takes the same per-machine choice for a conversation. --machine fly refuses on
pan worker run and pan lane start; on pan start it starts the issue’s work agent on a
new Fly machine, the same as --remote (see Work agents on Fly and
pan machines add-fly):
github_repo or gitlab_repo); if it does not, the error names the command that adds it
(see Projects across machines).
The other machine chooses the working directory: its own copy of the project, or its
default working directory (~/Projects, else home) when no project is chosen. With any
machine but This machine chosen, the dialog’s Working directory field is empty
and reads, for example, “Set by desk: its copy of Overdeck”. A directory you typed
applies only to this machine and is kept if you switch back.
Work started this way is link-started: the other machine records which machine asked
for it. An agent on your machine may then message and stop that work, and only that work.
It can never open terminals or port forwards there, create conversations or workers outside
the work doors, add projects, pair devices, mint tokens or change settings.
Delegation
pan worker run --machine <label|auto> starts a worker on another machine and gives you a
local stand-in id (agent-<issue>-worker-<n>). pan worker wait on that id mirrors the
remote worker’s reports exactly like a local worker’s.
- Offline: while the other machine is asleep or unreachable, the follower backs off (1 s, doubling up to 5 minutes) and keeps waiting; the wait does not fail. It resumes after a dashboard restart.
- Parent stop: when the agent or conversation that started the worker ends, this machine stops the remote worker.
- Unpushed commits: the other machine starts from its view of
origin. If your branch has commits that are not pushed, the CLI refuses and says so; re-run with--push-firstto push them, or--ignore-unpushedto start anyway.
Auto placement
Auto (--machine auto) picks a machine for you and prints why, for example
Auto → desk (CPU pressure 3%, 41 GB free, 2 agents). pan lane start adds a second line
when Auto passed over other machines, for example Passed over: laptop: no docker; desk: offline, and prints both lines when it picks this machine too. pan start and
pan worker run print only the first line.
- Candidates are this machine and every online, visible linked machine.
- A machine is skipped when it is offline, has no project for the repository, lacks a needed tag, has a saturated CPU, or is reserved. A reserved machine is still picked when it is the only machine with a needed tag.
- The rest are ranked by lowest CPU pressure, then most free memory, then fewest working agents, then this machine.
linux,
macos or windows, plus docker, gpu and ios-sim when they are detected. Add your own
tags, or reserve a machine, in its config.yaml:
--needs docker,gpu (and the dialog’s Needs field when Auto is chosen) limits Auto to
machines with every listed tag. The Machines list (pan machines list, Settings → Anywhere →
Machines) shows each machine’s load and tags.
For a conversation, when nothing fits, remote.auto_fly = true lets Auto create a Fly
machine instead of answering “no machine fits”, only when the project is on GitHub and
needs stays within what a Fly machine can have (linux, docker). It is off by default,
and it never applies to a worker, an issue start or a lane:
Gauntlet lanes
pan lane start --machine auto [--needs <tags>] places a gauntlet lane the same way, so a
loop’s heavy critics can run on an idle laptop or Fly machine instead of the orchestrator’s
machine. The orchestrator keeps the run’s rules and lists, waits on, stops and reaps the
lane from its own machine. --json carries the same explanation as
placement: { label, reason, rejections }; machine stays null for a lane Auto placed on
this machine. See Lanes on other machines.
Projects across machines
With Combine matching repositories across machines on (Settings → Anywhere → Machines, default on), the project switcher at the top of the left column shows one project per repository: a project that other machines also have shows ”· N machines”, conversations from those machines appear in its conversation list, and repositories that only other machines have are listed under On other machines. Add this project to <machine> clones the repository on the target machine through the normal project creation, registers it, and copies the git-ignored files you select:.env,
.envrc and .dev.vars are selected by default, files larger than 1 MiB, directories and
symlinks are never copied, and an existing file on the target is kept. Files cross only an
operator-level link, for the operator. From the CLI:
--file, --no-env and --parent-dir. Each Online row in Settings →
Anywhere → Machines also has Add a project (operator-level links only), which pushes
this machine’s project to that machine; Compare settings and Add a project show
only on Online rows.
Fleet Needs-You and search
Needs you lists questions and permission prompts waiting on every online linked machine, labelled “on <machine>”. A conversation on another machine opens through the link; an agent there is answered on that machine. The command palette’s search adds an “On <machine>” group for every online linked machine.pan machines who PAN-123 lists which
machines run agents or conversations for an issue. Offline machines add nothing. When this
machine cannot fetch the list of an online or connecting machine, Needs you shows
Can't reach <machine>; it may have items waiting. on the desktop and the phone until a fetch
succeeds. The row goes away after an hour without a failed fetch, for example when that
machine is switched off.
Fleet usage
The Costs page’s Machines tab (Costs is an experimental view: turn on Settings → Experimental → Experimental features to see it) shows today, week and month spend for each machine and an All machines total. An offline machine shows its last known numbers with “cached <time>”. A provider request recorded on two machines (for example a conversation pulled from one to the other) is counted once in All machines. See Costs and spend for how each machine’s spend is counted.Compare settings
Compare settings on a machine’s row (Settings → Anywhere → Machines) lists theconfig.yaml keys whose values differ between this machine and that one. Secrets show only
“set” or “not set”. Each value this machine sets comes with a copyable
pan admin config set <key> <value> line to run on the other machine; nothing is changed for
you. With a Tailscale route, Open <machine>‘s dashboard goes to that machine’s own
Settings.
Unlink
Unlink on a link (orpan machines unlink <label>) removes it here and tells the
other machine to drop its access token for this machine. If the other machine is
unreachable, it sees the link as Revoked when it next connects. The Inbound list
shows machines that hold access to this one; Remove revokes one and closes its open
connections.
Troubleshooting
- Unsupported: update Overdeck on the machine the state names, then Reconnect.
- Revoked: the other side unlinked. Create a new pairing link there and link again.
- Update all skipped a machine: the toast and
pan machines updatename the reason. An offline or unsupported machine is never updated; bring it online (or install the named Overdeck version) and run Update all again. “agent-fenced” means this machine’s link to it is agent-fenced; link again at operator level to update it from here. - A CLI update failed: the row shows
Failed: <CLI>, and the Update cell’s tooltip (orpan machines versions --json) holds the command’s output. Fix the cause on that machine (often permissions on the npm prefix) and run Update all again; the other CLIs were still updated. - Offline with “ECONNREFUSED”: the other dashboard is not running, or no advertised address reaches it from here. Add a route you know works.
- Offline with “closed the connection before proving the pinned machine key”: every
route answered but none proved the expected key. Either the other machine’s key changed
(its
machine-key.jsonwas replaced) or a proxy answered for a dead peer. Unlink and link again if the key really changed. - “Secure channel to … did not open within 10000 ms” while the machine shows Online: the route reached the other machine but the connection and handshake took longer than 10 seconds. This is usually a slow moment on the route (for example the public Fly edge); run the command again. If it keeps happening, the route itself is congested: check the machine’s routes in Settings → Anywhere → Machines.
add-flyfails withunreachable: the Fly app has no public IPs. Runfly ips allocate-v4 --shared -a <app>andfly ips allocate-v6 -a <app>once, then try again. The failed VM was already destroyed.add-flyfails withversion-mismatch: the VM could not install this machine’s Overdeck version from npm. The message names both versions; a development build that is not published on npm cannot be installed there. With--harness codexthe message can also name@openai/codex: the VM could not install this machine’s Codex CLI version. Update the Codex CLI here to a published version, then try again.add-fly --harness codexfails withcredentials-failed: this machine has no Codex CLI or no valid Codex sign-in. Runcodex loginhere, then try again.Fly token rejected (403): checkpan doctor’sFly tokenrow for the origin and status, thenfly auth loginto refresh the stored login, or setFLY_API_TOKEN(or the variable[remote.fly] api_token_envnames) to a long-lived token fromfly tokens create deploy -a <app>(PAN-4748).- The link exists but
require_token_mintturned itself on: that is expected. Any remote access turns it on; see Remote access. - Still stuck? Ask on the Overdeck Discord or file a GitHub Issue.