What Is Remoot? Architecture of a Mobile IDE Companion

Remoot is a mobile companion for VS Code and Cursor: an app on your phone, a bridge extension in your IDE, and a relay between them. You pair once, mark the projects you want reachable, and from then on you can watch agent runs, browse files, and answer approval prompts from anywhere.

"Companion" is a deliberate word. Remoot is not a cloud IDE and not a code host — your workstation keeps the code, the toolchain, and the agents. This post explains the architecture that makes that possible and the privacy decisions baked into it.

The three parts

┌──────────┐   encrypted    ┌───────────┐   encrypted    ┌──────────────┐
│  Remoot  │◄──────────────►│   relay   │◄──────────────►│  bridge ext. │
│   app    │    session     │ (server)  │    session     │ VS Code /    │
│ (phone)  │                └───────────┘                │ Cursor       │
└──────────┘                                             └──────────────┘
                                                          your machine,
                                                          your code

1. The bridge extension

A standard VS Code / Cursor extension plus a small background daemon. It watches agent activity (Cursor Agent, GitHub Copilot CLI), serves file previews on request, exposes approval prompts, and keeps the session alive when the editor loses focus. It can optionally prevent the machine from sleeping during a run.

2. The relay

Phones and workstations rarely share a network, and asking users to port-forward or manage SSH keys is how tools stop getting used. The relay solves reachability: both sides dial out to it over TLS, so no inbound ports open on your machine and corporate firewalls are traversed the same way any HTTPS traffic is.

The relay's job is intentionally boring: authenticate sessions and forward encrypted frames between two paired endpoints. It is a pipe, not a datastore.

3. The mobile app

The iOS/Android app renders what the bridge sends: agent conversations, live run status, diffs and file previews, the approval queue, and action history. Push notifications fire when a run needs a decision, which is the feature the rest of the product hangs off.

Pairing and trust

Access is scoped twice, and both scopes are explicit:

• Trusted devices. Pairing happens through a QR code shown in the extension carrying a short-lived token. Only devices that complete that handshake can talk to your workstation, and you can revoke any of them from the extension.
• Trusted projects.The bridge only exposes folders you explicitly mark. The rest of your filesystem doesn't exist as far as the app is concerned.

The privacy approach

The design goal: the phone is a remote control, and remote controls don't need a copy of your codebase.

• Code stays on your machine.Remoot doesn't sync or index your repository. File content moves only when you request a preview, and it moves through the encrypted session.
• Transport is encrypted. Traffic between app, relay, and extension runs over encrypted channels; the relay forwards frames rather than mining them.
• Minimal account surface. The service keeps what it needs to run: account identifiers, device metadata for pairing, and reliability telemetry. The specifics are in the privacy policy, which is short enough to actually read.
• Approvals are the security model, not a speed bump. Agent actions that mutate state route through an explicit human decision — the same gate the CLI tools themselves impose, extended to wherever you are.

Why not just SSH / a cloud IDE?

Both work, and both answer a different question:

• SSH from a phone terminal gives you everything and makes all of it painful: key management, reconnects on network hops, and thumb-typing into tmux. Fine for emergencies, hostile as a daily loop.
• Cloud IDEsmove your environment to someone else's machine. That's a real trade — you gain reachability and give up locality, custom toolchains, and the answer to "where does my code live?" being "here".

Remoot picks the third corner: keep the environment local, make the supervisionremote. The IDE and its agents run where they always ran; the phone gets the two things it's genuinely good at — notifications and quick decisions.

Where to start

If this sounds like your workflow, the practical guides are running Cursor Agent from your phone and monitoring GitHub Copilot CLI on mobile. The extension is free; the app has a free tier with the setup below.