Multi-Machine Management

Cloud and self-hosted

Account-linked multi-machine management, including machines outside your own network, is available in the Cloud version. The self-hosted version can also span several machines that can reach each other directly (same network or Tailscale), with no account — see "Pair machines without an account (self-hosted)" below.

ADHDev Cloud lets one account keep track of multiple development machines from a single dashboard.

What It Gives You

• one dashboard for your laptop, desktop, work machine, or remote box
• machine-aware session visibility across IDE and CLI workflows
• a machine detail page with launch controls, provider settings, logs, and session-host recovery
• cloud access outside your local network

This is one of the clearest differences between cloud and self-hosted. Cloud is the account-linked control plane. Self-hosted is a local dashboard on a host machine, which can take in paired machines on a network it can reach.

How It Works

Each machine runs its own ADHDev daemon, authenticated to the same cloud account:

npm install -g adhdev
adhdev setup
adhdev daemon

Once the machines are connected under the same account, they appear together in the dashboard.

Repo Mesh (daemon-to-daemon orchestration)

Repo Mesh coordinates multiple same-account daemons so one coordinator session can drive work across several machines or git worktrees. It runs over a direct daemon-to-daemon P2P DataChannel (via node-datachannel); the cloud server WebSocket relays only SDP offer/answer/ICE signaling and authorizes that both daemons belong to the same account. This is daemon coordination — it is not a dashboard command fallback. Dashboard command/data traffic still uses the dashboard↔daemon P2P channel only.

The cloud dashboard surfaces the mesh on the Repo Mesh page (/mesh).

Core concepts:

• Node — a workspace taking part in the mesh: a repo checkout or an isolated git worktree where an agent can run.
• Mission — a goal that groups the tasks working toward it and stays as a durable record.
• Task — a unit of work an agent on a node performs, moving through pending → assigned → completed/failed.
• Queue — the daemon-local list of waiting tasks that idle nodes autonomously claim. The queue is local-first and authoritative; Cloud/D1 holds only lightweight membership/signaling metadata.
• Ledger — the append-only mesh audit log of what has already happened across nodes (history, not a to-do list). Reconciled between daemons over bounded P2P ledger slices.
• Refinery — the process that converges a worktree branch back into its base: validate → merge → push → clean up.

The coordinator daemon owns the aggregate mesh_status snapshot. Worker sessions are coordinator-dispatched and auto-approved by default. Completion is evidence-based (git status/checkpoint, ledger events), not LLM self-report. Repo Mesh tools are exposed to coordinator sessions through the MCP server in mesh mode — see MCP Server.

For the full picture — pull-based orchestration, worktree-isolated repo collaboration, refinery convergence, and cross-verification — see the dedicated Repo Mesh guide.

Machines

The Machines page is the machine-level overview. It is where you quickly see:

• which machines are online
• which machine a session belongs to
• connection and runtime status
• which machine you want to open in detail

Machine Detail

Opening a machine gives you a more operational view than the main dashboard:

• Workspace for current IDE and CLI sessions
• Hosted Runtimes for hosted CLI runtime diagnostics and recovery
• Providers for machine/provider settings
• System for machine health
• Logs for runtime and daemon logs

This is the page you use when the high-level dashboard tells you something is wrong but you need machine-specific context.

Typical Uses

Multi-machine cloud setups are especially useful when you:

• keep one machine on background agent work
• separate personal and work devices
• want mobile approvals for sessions running somewhere else
• need to recover a CLI runtime on a machine you are not physically using

Plan Limits

Plan	Max Machines
Free	1
Pro	2
Ultra	5
Enterprise	Unlimited

When you hit your machine limit, additional machine registrations are rejected until you remove one or upgrade.

Self-hosted Difference

Self-hosted does not merge machines into an account-linked hosted dashboard.

Use self-hosted when you want a local-only dashboard, optionally with paired machines on a network that can reach each other. Use cloud when you want account-linked machine visibility across devices and networks.

Pair machines without an account (self-hosted)

Since 1.0.76 (fixed end to end in 1.0.77), a free standalone daemon can span several machines. Machines that can reach each other directly (same network or Tailscale) pair with an address and a one-time code from the mesh screen. The host machine hands tasks to the others and shows their sessions. No cloud account is needed.

1. Start the host on an address the other machine can reach. The default is 127.0.0.1 (this machine only), which other machines cannot connect to. Use adhdev standalone --host 0.0.0.0 --token <some-secret>, or bind a LAN or Tailscale IP. If the daemon is loopback-only, the pairing card shows a warning telling you to restart with --host 0.0.0.0 (or a LAN/Tailscale IP).
2. Create a code on the host. Open the mesh screen, find the Connect another machine card, stay on the Host tab and click Create pairing code. The card shows the Address (use this machine's LAN or Tailscale IP and the port, 3847 by default) and the Code. The code is shown only once and has an expiry time; use Copy to copy it.
3. Join from the other machine. On that machine, create (or open) a mesh for the same repository, open the Member tab of the same card on its mesh screen, enter the host's address as host:port (for example 100.64.0.2:3847) and the code, then click Connect. The card confirms the pairing and shows Waiting for connection until the link is up.
4. Manage it from the host. Paired machines are listed under Connected machines on the Host tab; use Disconnect to remove one.

Once paired, the assistant can also pass your requests to a project hosted on the other machine and bring the result back into its chat.

Security

Mesh peers do not use the dashboard token. Each machine authenticates on /ws/mesh with its own pairing secret (an HMAC handshake). Binding to 0.0.0.0 without a dashboard token or password makes the dashboard reachable by anyone on that network, and the server prints a warning at startup — see Standalone for the details.

What stays Cloud-only:

• reaching machines outside your own network (cloud P2P with TURN)
• push notifications
• the hosted REST API and API keys
• project file transfer between machines (standalone cannot open the WebRTC file link)

Naming Machines

Friendly machine names matter once you have more than one box connected.

Machine nicknames appear throughout the dashboard and help disambiguate where a session is actually running.

Next Steps

• Dashboard →
• Mobile →
• Plan & Limits →