Persistent Terminal Sessions Across Devices

When the connection drops, an ordinary terminal session ends with it

A conventional terminal session is tied to the connection that created it. If you are working over SSH from a laptop or a phone and the network drops, the session is closed and the shell is gone — along with whatever was running in the foreground at the time. On mobile networks this is not an edge case: switch from Wi-Fi to cellular, walk into an elevator, lock your phone, and the session you needed is dead.

Starting over is annoying when it costs you a few typed commands. It is much worse when the session was running a long build, a model training job, a deploy script, or an interactive coding agent that had accumulated an hour of context.

tmux and screen keep sessions alive on the host — and add their own overhead

Terminal multiplexers such as tmux and GNU screen solve the core problem and have done so for decades: the multiplexer runs on the host, shells live inside it, and you attach and detach as you come and go. If you already live in tmux, this is a solid setup and there is little reason to change it.

The trade-off is that everything around persistence stays manual: install the multiplexer on every machine, learn its keybindings and commands, remember to start sessions inside it before you need them, and still arrange a way to reach the host from outside your network — typically SSH plus port forwarding, a VPN, or a tunnel. None of that is hard for a systems engineer; all of it is friction for everyone else, and none of it gives you a good client on your phone.

CLIAnywhere builds persistence in, then adds phone and browser clients

In CLIAnywhere, every session runs under the daemon on your computer from the moment it starts — there is no separate attach step to remember. Clients come and go: your desktop while you work, your phone when you leave, a browser on another machine later. Attaching never restarts the session; it opens a live view of the one the daemon is already holding.

At your desk

Start the session

Work at your computer as usual. The shell runs under the daemon, so persistence is already in place.

Away

Check in from your phone

Open the app on your phone — or the Web App in any browser — and read the output that kept accumulating.

Back

Pick up where you left off

Return to your desk — or any device — and reattach to the same session, with everything still in place.

The session in the middle never stops. Disconnects — phone or desktop — only remove the view, never the session.

Long-running tasks keep going while you are away

Persistence matters most for work that outlasts your attention: builds and test suites that run for tens of minutes, model training jobs, deployment scripts, and interactive AI coding agents that can run for hours. With the session held on your computer, you can walk away and check in from your phone whenever you want — the task never noticed you left.

# start a build at your desk, then leave
$ npm run build
... you lock your PC's screen and head out ...
# from your phone, later — same session, still running
Compiled successfully in 612s
$ ./deploy.sh
Deploy complete.

The same applies to AI coding agents that run in a terminal. For that scenario in detail, see monitoring AI coding agents from anywhere and running Claude Code remotely from your phone.

Facts

Platform and feature facts

What persistence in CLIAnywhere is built on.

Windows host	Yes
macOS host	Yes
Linux host	Yes — desktop UI or headless CLI
iOS client	Yes
Android client	Yes — Google Play
Web client	Yes — webapp.clianywhere.com
Shells	bash, zsh, fish, sh, cmd, pwsh, powershell
Persistent sessions	Yes
Desktop–mobile session switching	Yes
File browser and download	Yes
Localhost / LAN web access	Yes
P2P direct connection	Yes — DTLS
Encrypted relay fallback	Yes — WSS
End-to-end encryption	SPAKE2 + AES-256-GCM
Port forwarding / public IP required	No
Open-source daemon	Yes
Account model	One account, multiple PCs, per-PC local Security Code

FAQ

Questions about persistent terminal sessions

A persistent terminal session is a shell session that keeps running on the host computer after the client that was viewing it disconnects. When you come back and reconnect, you find the same shell still alive, with its running processes, command history, and scrollback intact, instead of a fresh session.

With CLIAnywhere, any session started through the daemon on your computer keeps running when you disconnect — there is no extra command to remember. If you use plain SSH today, the usual fix is a terminal multiplexer such as tmux or screen on the host, which also keeps the session alive but requires installing it on every machine and learning its commands.

Open the CLIAnywhere client on your iPhone, Android device, or in a browser, sign in, and select your computer from the list. You are reattached to the session running under the daemon, exactly as you left it — same shell, same working directory, same running processes, and the output produced while you were away is in the scrollback.

No, not for keeping sessions alive across disconnects and devices — CLIAnywhere handles that for every session it runs. tmux still does things CLIAnywhere does not, such as splitting one terminal into multiple panes and windows, so people who rely on that workflow keep it. If you already run tmux, it works normally inside a CLIAnywhere session.

Open the Web App at webapp.clianywhere.com in a browser on that computer, sign in with your account, and select your PC from the device list. The browser attaches to the same session the daemon holds on your PC, so you can continue the shell from any machine without installing anything.

Persistent Terminal Sessions