A long Claude Code task should not depend on your laptop staying open or your Wi-Fi staying up. Run Claude Code on the laptop, and closing the lid stops it. Run it on a server over SSH, and a dropped connection stops it. The form that fits is a private PWA (progressive web app): a web page that installs like an app, and that only you can open. The agent works on a machine of your own that stays on, and every device you carry is a window onto it.
On the laptop: you cannot close the lid
This is where everyone starts: claude in a terminal, in the project's folder.
Then a task needs twenty minutes and you need to leave. Close the lid and the laptop sleeps, and the agent sleeps with it. Open it an hour later and the task is where you left it, with the twenty minutes still to go.
A laptop can be told not to sleep. Then it has to stay where it is, on power and on its Wi-Fi, until the agent is done, and you leave without it.
Over SSH: you cannot lose the Wi-Fi
So the agent moves to a machine that never sleeps: a desktop in the corner, a Mac mini, a rented server. You SSH in and run claude there.
Now the lid cannot stop the machine. It can still stop the connection, and the agent lives only as long as the connection does. Lose the Wi-Fi for more than a moment, let the laptop sleep or move to another network, and the SSH session breaks. Claude Code is cut off with it, in the middle of its work. claude --resume brings the conversation back, but not the work it would have done in the meantime.
tmux mends that. It keeps a terminal alive on the server with nobody attached, so the agent works on and you attach again later. It also hands you a list of chores:
- Start tmux first, every time. The task that turns out long is the one you started without it.
- Remember which session holds which conversation, and attach to the right one after every drop.
- Put a terminal app and an SSH key on every device you want to look from. On a phone, every tmux command starts with Ctrl-B, typed on a touch keyboard.
- Look in now and then to see whether it has finished, because nothing tells you.
None of this is hard. It is logistics, and it comes back every day.
As a PWA: neither matters
Put the two lessons together. The agent belongs on the machine that stays on. What you hold in your hand should be only a view of it, one that can go away at any moment and come back with nothing lost.
A web page is that kind of view. Every device already has a browser, so there is no terminal app to set up and no SSH key to copy. A page that loses its connection can find it again by itself. And a page installed as a PWA gets an icon, a window of its own and notifications, so it can tell you when the agent is done.
exe is built this way. It is a desktop in your browser, served by a machine you own, and Claude Code is one of the windows on it.
- Each conversation is a session on the machine. Close the tab, close the lid, lose the Wi-Fi: the agent works on.
- A column lists the sessions. A pulsing green dot marks one that is still working, a black dot one that waits for you. A window whose connection dropped reconnects by itself.
- Every device opens the same conversation. Start a task on the laptop and look in on it from the phone.
- The phone tells you when it is done. With notifications on, it says Claude Code finished, and a tap opens that conversation.
Under the window it is still tmux: each session is a tmux session that exe starts, names and attaches for you. What tmux does has not changed. The logistics have moved from you to the app.
Only you can open it
A window onto Claude Code is a shell on your machine, with your code and your sign-ins behind it. It cannot be a page on the open internet.
exe leans on Tailscale for that. Tailscale is a private network between your own devices, and it reaches the machine from wherever you are. exe listens on the machine's address in that network, so the desktop opens from your laptop, your tablet and your phone, and from nowhere else. On top of that sits an API token, a password for the desktop.
On a machine you own
That leaves the machine. Ideally it is a small one at home: an NVIDIA DGX Spark or a Mac mini. Either is quiet, takes little room on a shelf and can stay on day and night. Tailscale reaches it there with no port opened on your router.
That machine has more to do than hold a terminal. The agent's builds and tests run there. So do the virtual machines exe gives the agent as sandboxes, and any model you run yourself. That takes cores, memory and a GPU, and a DGX Spark has 20 cores and a GPU that shares 128 GB of memory with them.
You could rent that in the cloud. But a GPU with that much memory is billed by the hour, and this machine cannot be switched off between tasks, because the agent lives on it. Kept on all year, the rent comes to more than the box costs. A box you own is paid for once.
Try it
You need a Linux machine or a Mac that stays on, with tmux on it and Claude Code installed and signed in. Tailscale goes on that machine and on every device you will look from.
curl -fsSL https://exe.v2core.com/install.sh | sh
- When the installer asks where exe should listen, choose the Tailscale address. It suggests an API token and prints it with the desktop's address.
- Put HTTPS in front of the desktop with Tailscale Serve, which keeps it inside your private network. Installing as an app and notifications both need HTTPS.
- Open the desktop on your phone, paste the token when it asks, and install it: Add to Home Screen on an iPhone.
- Turn notifications on.
The rest is in Getting Started, and the source is at github.com/livid/exe.
Then open Claude Code, give it something long, and close the lid.