AI Engineer Europe 2026

remobi.app: Don't change your terminal workflow for mobile

Loading slides…

Read the talk

Remobi: take your terminal workflow onto your phone

Connor Adams demonstrates how Remobi brings an existing tmux workspace to a phone, preserving custom agent controls, code review tools, and the responsibility to secure remote access.

From a talk by Connor Adams

Before you start: Familiarity with a shell, Git diffs, and terminal coding agents will help; tmux’s workspace structure is introduced along the way.

Do the agents need you?

You are out with friends or family, but the coding agents are still running. Are they making progress? Do they need steering? Connor Adams describes the compulsion to check—and his ambivalence about making that easier. Remobi grows out of that tension: if you are going to reach for your phone, you should be able to reach the workflow you already use.

There are already mobile agent apps. Adams jokes that his own urge to build another is a case of “AI psychosis,” but he also has specific objections to the available choices. He describes Happy as a native mobile interface for Claude Code, limited to that agent, with a relay server he personally does not trust. That comparison belongs to the recording: Happy’s current README supports Codex too and describes end-to-end encryption; Adams’s distrust is not a demonstrated vulnerability.

Dark Happy webpage with the heading “Claude Code Anywhere,” a terminal panel, and a phone showing a session list.Open full source frame
Happy’s “Claude Code Anywhere” page pairs a terminal demonstration with a phone interface.

The other routes each introduce a different kind of friction:

Route described in the talkFriction for Adams’s workflow
Built-in Claude Code mobile handoffRequires an explicit transfer; does not cover Codex or Pi in his account
General-purpose phone terminalRequires SSH-key setup and usable touch controls
Existing terminal customizationsNeed to remain accessible from the phone

The last point becomes the organizing requirement. Adams already has a workflow built around tmux, and wants mobile access to preserve it.

0:280:36
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:28 · section reference included

Build the workspace in the terminal

Adams previously worked primarily in VS Code. His terminal setup now lives on a remote development machine that he can reach over SSH, giving him the same tools wherever he connects. Before showing the phone, he opens that desktop workspace: four coding agents share a terminal, arranged in separate panes.

tmux supplies the workspace structure. Panes divide a window; multiple windows provide separate views, with tabs along the bottom. The status bar is configurable too: Adams uses it for CPU usage and other machine information, with shortcuts that open additional status views. A minimal shell example of the pane-and-window structure is:

bash

# Create a workspace with two side-by-side panes.
tmux new-session -d -s work -n agents
tmux split-window -h -t work:agents

# Add a separate window, then enter the workspace.
tmux new-window -t work -n tools
tmux attach-session -t work

The names work, agents, and tools are example choices; the useful structure is a session containing windows, each of which can contain panes.

Custom commands extend that structure. Adams opens a launcher that offers a choice of agent counts, considers sixteen, and selects four. This is a demonstration of configurable workspace creation, not a throughput measurement. He says he generated the configuration with AI despite not knowing how to implement all of it himself: describe the desired interaction, then have the agent produce the tmux configuration.

He acknowledges apps such as Conductor, but prefers to own his workflow while experimenting with how to manage coding agents. The terminal gives him somewhere to put those experiments without first committing to a larger application’s interaction model.

2:162:34
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:16 · section reference included

Keep review and maintenance close to the agents

Once Claude Code finishes a change, the next task is to inspect it. Adams presses a shortcut to open Lazygit in a terminal window, where he can navigate the repository and scroll through changes. Code review remains part of the same workspace as the agent that produced the code.

Terminal interface with files, branches, and commits on the left and code diffs on the right.Open full source frame
Lazygit displays repository navigation alongside code changes in the terminal.

He then opens another scrollable diff view, called Critique, to make the same point: the workflow includes checking changes before committing them. These tools give the agent’s output somewhere to go besides directly into a commit.

The custom tools also cover local maintenance. A development server will not start because a port is occupied; Adams’s utility reveals an agent browser process using it and lets him kill that process. Small, frequently needed operations can become terminal shortcuts alongside agent management and Git review. He undercuts the productivity story with a joke: all this customization can still leave you shipping nothing that users actually use.

4:054:22
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:05 · section reference included

Open the same workspace on a phone

With those customizations in place, Adams switches to his phone. Remobi is a progressive web app, which he describes as working on iOS and Android, backed by a server running on his machine. He mentions a Pi version, then selects the machine used in the desktop demonstration. The phone opens the workspace where he left it.

The first interaction exposes some roughness: a scrollback-related shrinking behavior does not work as expected, which Adams attributes to switching views. He then moves through the controls that make the existing workflow usable on a touchscreen:

  • Agent mode: a Shift+Tab control switches the demonstrated agent into plan mode.
  • Git review: a dedicated control opens the Git interface.
  • Diff inspection: another opens Critique, with gestures for scrolling through the view.

These controls make terminal actions available without requiring every keyboard combination to be entered through the phone’s keyboard.

Adams is blunt about the appearance: he considers it minimally functional, not polished. The pane gestures are the practical part. Double-clicking zooms into a pane; he tries scrolling one with no content to scroll, moves to another, and demonstrates scrolling and zooming back out. The aim is to retain the multi-pane workspace while making an individual pane usable on a small screen. The phone adapts to the workflow already built in tmux.

5:195:31
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:19 · section reference included

Adapt the touchscreen controls to your setup

Remobi is open source. Adams introduces its shell-script installation path with sarcasm about the wisdom of copying arbitrary commands into a terminal. The guided setup installs a skill that helps configure tmux if you do not already have it. For an existing tmux setup, it turns your bindings into controls for Remobi’s touchscreen interface. The setup therefore accommodates both a new workspace and one with established custom commands.

Remobi README with installation command blocks and a “Why remobi” list covering gestures, home-screen installation, configuration, and self-hosting.Open full source frame
The Remobi README shows installation commands and configurable terminal controls.

The guided script is optional: Adams also describes installing the skill and npm package directly. He closes the installation walkthrough by asking for GitHub stars, even from people who do not plan to use the app.

6:507:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:50 · section reference included

Session access and the security boundary

The audience questions fill in two missing pieces. First, is remote control itself a tmux feature? Adams separates the responsibilities: tmux provides the panes and workspace, while Remobi calls tmux and takes the user straight into the session. The demonstrated setup hides that session-entry step rather than asking the phone user to manage it each time.

The second question is how the phone communicates with the machine. Remobi is a website accessed over the network. Adams uses Tailscale, and names Cloudflare Tunnels and ngrok as alternatives. His central qualification is that security depends on how that access is configured. Connectivity and authorization are separate responsibilities: providing a route to a terminal does not, by itself, establish who may use it.

That distinction matters because this interface controls a real development machine. Adams warns that putting the service directly on the public internet means “you've pwned your own computer.” An audience member then asks whether Tailscale is the default setup, explaining that otherwise they would be worried. Adams explicitly confirms that it is. The convenience of reaching the existing session from anywhere ends at this boundary: access to the phone interface must remain controlled access to the machine.

7:548:02
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:54 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…