# Tade on a server of yours, and one window over all of it

> A VPS of yours runs Tade with the laptop shut, and the Mac's window shows and drives every machine's projects over SSH. One Tade per machine, nothing merged.

Published 2026-10-18 · by The Tade project · tagged remote, vps, agents, safety.
Published at https://tade.sh/blog/tade-on-a-server-of-yours/ — part of https://tade.sh/blog/.

---

Agents work for hours, and a laptop does not stay open for hours. Until now
that was the end of it: close the lid and the work stopped with the window.

**Tade now runs on a server of yours as well as on your Mac, and the Mac's
window shows and drives both.** A Debian or Ubuntu box you can reach over SSH
runs `tade serve` — the window with no screen — under systemd, and carries on
with nobody connected. The Mac links to it with one command and draws its
projects as tabs beside its own.

It is on Tade's `main` and not in `tade-sh` 0.2.3, which is what npm installs
today. Until a release carries it, the way to it is the `source` rows under
[Install](/#install), on the server as on the Mac.

## One Tade per machine, and nothing merged

Each machine keeps its own home, its own journal and its own agents. Nothing is
copied into one big history, and no machine is the other's database. The Mac
holds one SSH connection to each server and draws what that machine says:
every project under the name of the machine it is on, each tab with the marks
that machine gave its agents. So the `tade` on the Mac and the `tade` on the
VPS are never two tabs nobody can tell apart.

> **A screen from Tade — `a-project-on-another-machine`.** Standing in tade on the VPS, from the Mac: the side lists its agents with the marks the VPS gave them and how long ago each moved, its queued work under them, and the pane says where it is — on vps — and how it stands: one wants you, two working, one queued.
>
> Standing in `tade` on the VPS, from the Mac: its agents with the marks the VPS
> gave them and how long ago each moved, and its queued work under them.

An agent there opens here. Its screen on that machine, read-only, with what
that machine says may be asked of it — steer it, park it, stop it, allow or
deny what it is held on — and Enter types into it over the SSH connection the
link already holds, or mosh where both machines have it. Closing the tab ends
the terminal and never the agent.

> **A screen from Tade — `an-agent-on-another-machine`.** An agent on the VPS, opened from the Mac: what it is and how it stands there, the controls the VPS says may be used on it — type into it, steer it, park it, stop it, allow or deny the call it is held on — and its screen there, read-only, as the VPS last read it.
>
> An agent on the VPS held on a `gh api` call, opened on the Mac: the presses the
> VPS offers, the whole command as it sent it, and its screen there.

## With the lid shut

Hand what is still running on the Mac to the server before the lid closes, and
the server carries on: its agents, its queue, its schedules, its watches and
the work that arrives from outside. A watch runs on exactly one machine — the
server by default — so one red build is one finding and not two.

When the lid opens and the link comes back, the server's tab says what happened
since you were last at the keyboard: what waits on you, what finished, what is
held and what it cost.

> **A screen from Tade — `another-machines-orchestrator`.** The VPS’s orchestrator on a tab beside the Mac’s own: what was asked of it last night, then what it says happened since the person was last there — the agent waiting on them, what finished, what is held, what it cost — and that what is typed here goes to the VPS.
>
> The VPS's orchestrator on a tab beside the Mac's own, with what it says happened
> since you were last there.

One Mac can link to as many servers as you have: `tade remote add` once for
each. A link that drops does not blank anything — the rows stay as that machine
last said them, with `○` and the time.

## Setting one up

```sh
# on the server, over SSH
curl -fsSL https://tade.sh/install.sh | sh
tade setup                          # it knows the box has no screen
tade host service                   # the systemd unit for `tade serve`; starts it
tade host domain tade.example.com   # the DNS records a phone and webhooks need, each checked
tade host caddy                     # the site block for Caddy 2.7 or newer

# on the Mac
tade remote add vps --ssh vps       # its projects become tabs in this window
tade remote connect vps             # GitHub, Slack and Linear on its guided page
```

Every step says what it found before it changes anything. `tade host domain`
checks each record and says whether it is missing, wrong or not yet visible,
with the exact record to add. `tade remote add` shows a box it has never met by
its host key's fingerprint, and carries your preferences, personas and
templates — **your keys wait on a press.** Connecting GitHub, Slack or Linear
makes an app of your own from a manifest, and a signed webhook to the server's
public name only ever makes a watch look sooner.

## A box on the internet

A public name is a second decision, and Tade still never listens on the
internet itself. Caddy sits in front, over a socket only Caddy can open, and
whatever arrives that way is public — never this machine, never a session
paired on it. A phone pairs with a code printed over SSH and then makes a
passkey, and from the public name it acts only within twelve hours of using it,
so a session copied off a phone reads and cannot act. The Mac is an owner device
minted over SSH, and works through SSH and never over the public name.

What Tade still does not do on a server is contain an agent. Agents run as the
user Tade runs as, on every machine, so an agent on that box can read what Tade
can there, its keys included.

## What is proved, and what is not yet

The whole of this was rehearsed from nothing on fresh Debian 12 boxes and an
isolated Mac, and it is held by a test that runs in CI: two real `tade serve`
through a real sshd, linked by the real `tade remote add`. Not yet proved on a
real VPS with a real domain: a Let's Encrypt certificate, real DNS and DNSSEC,
real webhooks from GitHub, Slack and Linear, a real phone's passkey, and
`tade host upgrade` from npm under systemd.
