# Terminals in Your Pocket (1): Why Reach Your Computer From a Phone

- URL: https://wuming.si/blog/4083/
- Author: Wuming
- Published: 2026-10-02
- Language: en
- Categories: Technology, English

> Next: [An Architecture of Three Parts](https://wuming.si/blog/4084) | 中文版：[为什么要在手机上接管电脑](https://wuming.si/blog/4078)

Picture this. You hand a coding agent a task: refactor a module, run the tests, commit the result. It starts reading files, editing, running commands. Output scrolls past. You sit there, not sure what to do with yourself, and not quite daring to leave.

Because at any moment it stops to ask: delete this file? May I run this command? The tests failed, continue or roll back?

You go for a coffee, come back, and it has been waiting fifteen minutes. That happens five or six times a day, and you realise a very diligent intern has you chained to your desk.

This series is about a small set of tools built to fix that. The computer stays a computer, the agents keep working inside it, and the person can be anywhere, on any device, watching progress, answering questions, typing a few more commands. Nothing in it is deep, but a lot of the trade-offs are worth writing down.

## What the problem actually is

Pull it apart and it is three old problems stacked together.

First, long tasks need a human in the loop. The more capable an agent gets, the longer it runs and the more decisions it needs along the way. Those decisions arrive at random, so nobody can plan when to come back.

Second, the work already lives on the computer. Code, dependencies, build caches, a local database, every kind of credential. Moving all of it to a cloud workspace is a separate project, and plenty of companies forbid it.

Third, a phone is not a computer. Small screen, weak keyboard, flaky network. Mirroring a desktop into it works, but it is miserable.

The usual answers each solve a piece. SSH plus a VPN plus tmux gets you back in from outside, but it is fiddly, bad on a phone, and knows nothing about agents. A cloud IDE feels great, once your code and secrets have moved house. Remote desktop ships pixels: heavy, slow, hungry for data, and equally blind to what is happening in the terminal.

## A few decisions

Before building anything, a handful of principles were fixed. Everything later was derived from them.

**The computer is the centre; the phone is a window.** Nothing moves to the cloud. The phone, a tablet, a browser are windows onto the computer. Close the window and everything on the computer carries on.

**tmux is the only truth.** Terminal sessions should be long-lived anyway. The tmux windows open on the computer are exactly the windows the phone can see; there is no second session model. What you type at the desk and what you type on the phone go into the same pane.

**Connect directly; don't detour.** The phone and the computer talk to each other with no server in between whenever the networks allow. When they don't, traffic goes through a relay that only ever sees ciphertext. A keystroke should not take a round trip through someone's data centre.

**Code never leaves the computer.** This follows from the previous point. If nothing in the middle can decrypt, source, keys and environment files stay where they are. Some directories are simply never shared.

**Understand agents, don't replace them.** The tools must know whether an agent is running, waiting for a person, or finished, so they can notify at the right moment. They don't run models, they aren't an IDE, and they don't pick which vendor's agent you use.

**Any device.** iPhone, Android, a tablet, a borrowed laptop's browser: sign in and your computers are there. Hotel Wi-Fi, mobile data, a corporate firewall all have to work without touching a router or installing a VPN.

## What it ended up looking like

From the user's side it is three steps.

Install a small resident program on the computer and sign in. It takes over the machine's tmux sessions and stays reachable in the background. Install an app on the phone, or open a web address in a browser, sign in with the same account, and the computer and each of its windows appear. Run one more command on the computer so agents notify the phone when they stop.

After that, a day goes something like this. Before leaving the office you hand the agent a big task. On the train you glance at progress. When it has a question, the options show up on the lock screen; one tap and the answer lands in the terminal, and the agent carries on. By the time you get home it is either done or waiting on the next question.

Everything that grew later, browsing files, sending a screenshot, sharing a window with a colleague, looking at the desktop, is a branch off that core.

## The series

1. Why reach your computer from a phone (this post)
2. [An Architecture of Three Parts](https://wuming.si/blog/4084): a resident process on the computer, a control plane that authenticates but can't decrypt, relays that forward only ciphertext
3. [Teaching Coding Agents to Knock](https://wuming.si/blog/4085): knowing when an agent waits, and sending an answer back safely
4. [The Computer Decides Who Gets In](https://wuming.si/blog/4086): device keys, local approval, short-lived certificates
5. [Troubleshooting Notes](https://wuming.si/blog/4087): can't connect, didn't get the notification, keys that won't type

Each post has a Chinese version; this one's is [here](https://wuming.si/blog/4078).
