Rex Use Cases: Agents, Phone Sessions, and a Cloud Box

My first post on Superlogical Rex covered how Mitchell Hashimoto’s multiplexer is built: raw PTY bytes streamed to each client, a server that owns the session, Lua config, and a scriptable CLI. Once the beta actually lands on your machine, the question changes: what are people doing with it that they were not already doing in tmux or Ghostty?

Public testing opened on 5 October 2026 on macOS first. A month in, the Mac app and the Linux and FreeBSD servers are in testers’ hands, the iOS app is on TestFlight, and a Windows client is still pre-alpha. Rex remains free, needs no account, and collects no telemetry. The setups below come from the official agent skill docs, community repos, and testers sharing their daily workflows through mid-November 2026.

1. Make the agent draw the explanation in a split pane

The simplest workflow in this list is also the one I would try first.

While working on folded diff connectors in @pierre/diffs, Amadeus got tired of reading walls of agent prose trying to justify a refactor. Because Rex supports the Kitty graphics protocol (including over remote connections), an agent can open a neighboring pane and draw what it means. His prompt is one sentence:

i don't quite understand what you're saying, can you create a diagram using kitty graphics protocol in a rex pane in this tab?

The agent splits the tab, renders the diagram into the new pane, and keeps talking in the middle column. In Amadeus’s case, seeing the visual breakdown of how folded line moves and edits join or cut connectors made it obvious right away that Claude’s proposed simplification would delete behavior the architecture actually needed. He pushed back, and the agent withdrew the bad plan before touching the commit.

Amadeus’s Rex window: code on the left, Claude Code in the middle, and a Kitty graphics diagram on the right showing how folded move and edit connectors join

Two related setups take terminal graphics in Rex a step further:

• Interactive Wasm charts in a split. Patrick Smith renders interactive charts directly inside a Rex pane using QIP, his WebAssembly component runtime, complete with arrow-key inspection and linear/log scale toggles.
• Inline terminal images in Claude Code and TUIOS. Claude Code can render images inline when CLAUDE_CODE_FORCE_TERMINAL_IMAGES is set (Wassim Metallaoui published a small marketplace plugin that sets it up cleanly). Gaurav Gosain runs tuios over a remote Rex session on his phone over Tailscale, with benchmark PNG charts rendering straight inside the thread view.

Patrick Smith rendering an interactive revenue run-rate chart inside a Rex split pane using QIP WebAssembly components

2. Let the agent drive the workspace with rex skill setup

Rex ships a built-in skill for Claude Code, Codex, OpenCode, and Pi. Without it, a coding agent can still run rex --help and figure out the CLI by trial and error, but it burns tokens and time every session doing so.

Running rex skill setup (or picking Install Rex for Agents from the command palette with Cmd+Shift+P) detects the agents installed on your machine and wires them up:

rex skill setup
rex skill setup --session-naming   # optional: let agents name sessions after their task
rex skill status                   # check if skills and hooks are current or outdated

Under the hood, setup installs two pieces:

1. The skill file (~/.claude/skills/rex for Claude Code, ~/.agents/skills/rex for Codex, OpenCode, and Pi). It reads its reference straight from your installed rex binary, so upgrading Rex updates what the agent knows without re-running setup.
2. A session-start hook (~/.claude/settings.json for Claude Code, ~/.codex/hooks.json for Codex). At the start of a session, the hook tells the agent it is inside Rex and passes its session and block IDs.

Two small gotchas from the agent skill docs: Codex skips new hooks until you run /hooks once inside Codex and approve it, and Claude Code ignores hooks until you trust the project folder. If you use another agent such as Gemini CLI, Cursor Agent, or Devin CLI, tell it to run rex skill show and follow the printed guide.

How the agent picks where to act depends on how you phrase the prompt: saying “here” or “beside you” uses the agent’s own REX_SESSION and REX_BLOCK environment variables; saying “the focused pane” targets whatever tab you are currently looking at in the app; and naming a label always wins over both.

rex split
rex capture -b logs --trim
rex send -s build -w 2 'make test'
rex -S studio ls

Testers are already layering multi-agent workflows on top of those primitives. Luong Nguyen built a /rex-agent skill (and an agent-profile skill in github.com/luongnv89/skills) that spins up four Factory Droid sub-agents across separate repositories in the sidebar, each with its own harness, model, and thinking level.

Luong Nguyen’s Rex sidebar running four parallel Factory Droid sub-agents across separate projects

The video below shows a similar pattern with Pi: a lightweight harness (pi-agency) opens a Rex block, dispatches the task to the worker agent, and collects the response.

3. See which agent is waiting on you (OSC 7501 and community harnesses)

Running five agents in parallel only helps if you can tell which one is stuck on a permission prompt without clicking through every tab. Rex listens for OSC 7501, an escape sequence a terminal program emits to report whether it is idle, working (with optional progress), blocked on input, finished, or failed. When Terraform stops on an apply prompt or an agent pauses for approval, Rex badges the unfocused tab and session entry, and can fire a macOS notification or Dock badge per state.

Because OSC 7501 is an open spec rather than a private Rex IPC call, other tools are adopting it too. Charm’s Bubble Tea added support, Kristofer Lund wired it into Ratatui apps via session.set_program_status(...), and Kitty 0.50+ reads the same sequence.

Three community projects build directly on top of Rex’s agent state and pane APIs:

rexlauncher: one inbox for blocked agents

Tornike Gomareli’s rexlauncher opens a command-center overlay inside Rex with tabs for All, Needs you, Panes, Conversations, Screens, Skills, Layouts, and Actions. When an agent pauses on a Bash approval (make deploy ENV=staging) or asks a clarifying question, it surfaces at the top of Needs you so you can approve or answer inline without switching tabs.

Tornike Gomareli’s rexlauncher plugin inside Rex showing the Needs you queue with an inline Bash deployment approval prompt

Chompy: an unofficial Android client for agent approvals

Superlogical has not shipped an Android app yet, so Jeff Arese wrote Chompy for his own setup. It connects to Rex servers across all his machines, groups running agents by which ones need a human, and lets him answer a prompt or approve a command from his phone without dropping into a full terminal grid.

rexmod: a Neovim review loop beside the agent

Alpcan Aydın’s rexmod (demo thread) is the most ambitious mod so far. It turns a Rex tab into a four-step code review harness around Claude Code, Codex, OpenCode, Pi, or Antigravity CLI (agy):

1. Prompt. When you send a message, an agent hook triggers the rexmod Go CLI to snapshot the git working tree using a throwaway git index (leaving your real index untouched).
2. Change. As the agent edits files, a native Swift sidebar (RexModPanel.dylib, toggled with Cmd+Shift+E) lists Last Turn diffs alongside Uncommitted and Branch changes, plus an Info tab showing listening ports and plan usage.
3. Review. Clicking any file opens it in a Neovim pane right next to the agent at the changed line, with Mason auto-installing the language’s tree-sitter parser and LSP on demand. Pressing Space r on a line or visual selection opens a comment box.
4. Feedback. Pending line comments attach automatically to your next prompt as file:line notes, or you can push them immediately from the panel.

brew trust --tap alpcanaydin/rexmod
brew install alpcanaydin/rexmod/rexmod
rexmod-setup

One caveat worth taking seriously: to render its native sidebar inside Rex’s chrome, rexmod injects a weak dylib load command into your local Rex binary, re-signs the app ad hoc, disables Sparkle auto-updates, and uses its own hourly LaunchAgent to verify, update, and re-patch official Rex builds. It includes a clean uninstaller (~/Library/Application Support/rexmod/scripts/uninstall.sh), and you can pass --no-patch if you only want the hooks and Neovim integration without touching the Rex binary.

Alpcan Aydın’s rexmod running in Rex: Claude Code on the left, Neovim in the middle, and the Last Turn diff panel on the right

4. The same Claude Code session on your iPhone over Tailscale

This is the workflow that makes Rex feel genuinely different from local terminal multiplexers.

The Rex server on macOS embeds its own Tailscale node (tsnet). You do not even need the macOS Tailscale app installed on the Mac. When you pair the iOS TestFlight app, it attaches directly to the sessions already running on your Mac: no SSH port forwarding, no tmux attach command, and no separate mobile chat history.

Daniel San’s diagram of how the Rex iOS app connects over a WireGuard Tailscale tunnel directly to the Mac’s embedded Rex server

Daniel San documented the full setup, including a couple of Tailscale traps that are easy to hit on a fresh account:

1. Sign in to Tailscale inside Rex. Open Rex settings (Cmd+,), go to Server, and click Sign In under Tailscale. Pick your preferred hostname right away (it becomes name.tailnet.ts.net and gets published to public certificate transparency logs once HTTPS is enabled). Leave Tags empty.
2. Don’t click Update Server or Stop Server while working. Both buttons on that settings page restart the local Rex server and kill your active shells.
3. Enable HTTPS certificates in Tailscale DNS. Fresh tailnets have HTTPS certificates turned off by default, which causes Rex to stop with "HTTPS certificates are off for this tailnet". In the Tailscale admin console, open DNS. If you want to replace the generated tailXXXXXX.ts.net name with a friendlier tailnet name, click Rename tailnet before enabling HTTPS (once the first certificate is issued, Tailscale locks the name). Then click Enable HTTPS.
4. Bring Tailscale back up with your hostname. If you enable it from the CLI, always pass --hostname, otherwise Rex resets the node name to rex:

   rex server tailscale on --hostname your-mac-name
   rex server status

5. Pair the iPhone via QR code. Install Tailscale from the App Store on the iPhone, sign in to the same account, and accept the VPN profile. Then run rex server tailscale pair on the Mac, tap Get Started → Pair via QR Code in the Rex iOS app, and scan the terminal QR code.

Once paired, rex client ls lists your iPhone alongside the Mac client. Testers are using it exactly how you would expect:

• Ravi Vasavan sat at lunch in Fremantle and steered a Claude Code session running on his Mac Studio back in Melbourne.
• Tuong Le deleted the Claude mobile app because remote-controlling his desktop session was the only reason he kept it around.
• Victor Savkin says Rex is already his most-used app on both his laptop and his iPhone.
• Mikyo King points out the real downside: the iOS UI is still rough around the edges, and having every background agent one tap away in your pocket makes it much harder to stop checking work from the couch.

5. A Linux or FreeBSD server in the sidebar

Remote hosts in Rex are not SSH sessions wrapped in a GUI. On Linux and FreeBSD, the server docs define three ways to run Rex:

In Login mode (rex-login-server), Rex checks /etc/rex/accounts.jsonc (or services.rex.loginServer on NixOS), matches the caller’s network identity (such as tailscale:[email protected]), and opens a full login session through PAM (/etc/pam.d/rex-login-server) before handing the connection to that user’s personal Rex server. The login shows up in who, resource limits apply, and each user’s sessions survive even if rex-login-server restarts or upgrades. Note that today the login server relies on network identity like Tailscale rather than passwords or SSH keys; support for existing SSH keys is planned but not shipped yet.

From your Mac, any connected server can be targeted by an agent or script with -S:

rex -S [email protected] ls
rex -S remote new build --json
rex -S remote window new -s <session> tests --keep-open --json -- npm test
rex -S remote capture -s <session> -b <block> --trim

Sam Morgan points his Mac client at a Linux dev box so agents can spin up test and editor panes he can inspect without keeping Cursor open. Noppakorn Kaewsalabnil uses it to keep remote sessions alive across Rex app updates, and Steve Yegge ran Emacs alongside 20+ agents over hotel Wi-Fi across the US with near-local latency.

Spinning up disposable cloud boxes with rex-cloud

If you want an isolated Linux box for an agent without provisioning a VPS, Vercel Labs released rex-cloud (an MIT prototype, separate from Superlogical). It boots a 2 vCPU, 4 GB Ubuntu VM on Vercel Sandbox with Node.js, Git, Claude Code, and Codex preinstalled, then bridges the sandbox’s Rex server to a private Unix socket on your Mac.

Daniel San’s Rex window showing a Vercel Sandbox cloud host named remote in the sidebar, running Claude Code inside Ubuntu

Daniel San tested the setup on 10 November and noted a few practical details that save time:

1. Update Rex to build 1758+ and restart the local server. Use Rex → Install Update (Shift+Cmd+U), then open Settings → Server → Update Server… so the running background server actually loads the new version (otherwise Rex rejects the socket host).
2. Install and launch rex-cloud. It is not on the npm registry yet, so install the release tarball directly:

   npm install --global https://github.com/vercel-labs/rex-cloud/releases/download/v0.1.0-prototype.4/vercel-labs-rex-cloud-0.1.0-prototype.4.tgz
   rex-cloud start remote

   If your local shell exports VERCEL_ORG_ID and VERCEL_PROJECT_ID for another project, unset them first (or run rex-cloud setup) so rex-cloud creates its own tracking project. The VM boots in about 10 seconds.
3. Add the socket to Rex’s sidebar once. Open Settings → Remote Hosts → Add Remote Host…, paste the /tmp/rex-cloud-.../sandbox-remote.sock path printed by the launcher as the URL, and name it remote. That socket path stays fixed across stops and restarts.
4. Manage the sandbox lifecycle. Because the cloud VM has no browser, running claude the first time prints an OAuth URL you open on your Mac and paste back. After that, disk snapshots keep your cloned repos, installed packages, and Claude login across stops:

   rex-cloud extend remote --by 2h   # add time without interrupting running agents
   rex-cloud stop remote             # stop compute and snapshot the disk
   rex-cloud start remote            # boot from the snapshot (~10s)
   rex-cloud delete remote --yes     # wipe the machine and its snapshots

Two Macs signed in to the same Vercel account can attach to the same running cloud computer simultaneously, or you can pass --shared so teammates on the same Vercel project can join. Compute follows standard Vercel Sandbox limits:

6. Custom Lua panels, event scripts, and floating panes

Rex’s configuration file (~/.config/rex/init.lua) is more than a keymap. Because custom actions defined with rex.action can split panes, invoke CLI commands, and listen to server events via rex.on, testers are building IDE-like sidebars without waiting for official UI features.

Luong Nguyen’s rex-extensions (github, mcc, tabs, sshtab)

The best open-source example right now is luongnv89/rex-extensions (walkthrough tweet). It packages four self-contained extensions, each with its own install.js that appends a dofile(...) and rex.bind(...) to your init.lua, validates with rex config check, and reloads live:

• github (Cmd+Shift+G): Opens a right-hand pane listing open pull requests and issues for the current GitHub or GitLab repo (via gh or glab). Each item has a button to start an agent review or issue fix using a customizable profile (harness, model, thinking level, and prompt).
• mcc (Cmd+Shift+U): Adds a compact bottom strip showing 5-hour and weekly Claude Code quota usage across multiple mcc accounts, plus live CPU, memory, and network stats. Because it renders in a normal Rex block, it shows up on the iPhone client too.
• tabs (Cmd+Shift+L): Automatically labels each session with its hostname and each tab with folder · program (for example, devbox over skills · claude), including across SSH sessions.
• sshtab (Cmd+Alt+T): Opens new tabs or splits connected to the same remote SSH host and options as the pane you are already in. Even better, its Restore Agent Sessions feature watches for a Rex server restart and automatically types the resume command (claude --resume ..., codex resume <id>, OpenCode, Cursor Agent, or Pi) into each restored pane within 120 seconds.

git clone https://github.com/luongnv89/rex-extensions ~/.config/rex/rex-extensions
node ~/.config/rex/rex-extensions/github/install.js
node ~/.config/rex/rex-extensions/mcc/install.js
node ~/.config/rex/rex-extensions/tabs/install.js
node ~/.config/rex/rex-extensions/sshtab/install.js

If you want to test an extension before touching init.lua, run it directly against your live session with rex do ~/.config/rex/rex-extensions/github/rex-github.lua --action github_panel.

Luong Nguyen’s Rex workspace running rex-extensions: Claude Code in the center, the rex-github issue and PR panel on the right, and the rex-mcc multi-account quota bar along the bottom

Long-running Lua event listeners (rex.on)

In addition to one-shot actions, a Lua script run with rex do can subscribe to server events with rex.on and stay running in the background. The official docs give a 9-line script that renames every terminal block whenever its working directory changes:

-- label.lua: keep each pane labeled with its current directory name
rex.on("terminal.pwd_changed", function(ctx, ev)
  local dir = ev.pwd:match("([^/]+)/?$")
  rex.session.set_block_label{
    block_id = ctx.block_id,
    label    = dir,
  }
end)

Scriptable floating panes

Mitchell Hashimoto’s floating panes demo shows the built-in version of a scratch workspace: panes that hover above your main editor split, can be subdivided into their own splits (for example, a Git TUI on the left and two Nu shells on the right), and toggle in and out with a shortcut or Lua API call.

Mitchell Hashimoto’s demo of floating panes in Rex: a Git Changes TUI and two split shells floating above a background Neovim buffer

And if you want your coding agent to look up Rex’s Lua API, CLI flags, or past troubleshooting threads without leaving the terminal, Superlogical hosts a Discord-authenticated Community MCP server. Daniel San wrote up how it works: it indexes the docs, #changelog release notes, and archived beta Discord threads. Just name the MCP server superlogical rather than rex so it does not collide with the rex CLI skill.

Which workflow to try first

Rough edges testers are still hitting

Rex ships updates almost daily, so some of these will age out quickly, but they are the real friction points in November 2026:

• Server restarts keep the window layout but drop running processes. When you update the Rex server, panes come back as fresh shells. Penn noted that manually resuming a dozen coding agents after an upgrade pushed him back toward dedicated orchestrators. Installing sshtab from rex-extensions (restore_agent_sessions) works around this for Claude Code and Codex by auto-typing their resume commands on restart, though native process survival across server upgrades is only there for Linux rex-login-server user servers today.
• The iOS client is functional but early. Pairing over Tailscale is slick, and reading or replying to an agent works well, but the mobile UI is noticeably behind the macOS app.
• rexmod requires binary patching for its sidebar. Injecting a dylib and replacing Sparkle updates with a custom LaunchAgent is clever for personal tinkering, not something to mandate on a work laptop.
• rex-cloud snapshots disk, not memory. When a Vercel Sandbox times out or stops, your repo and Claude login survive on disk, but running processes and terminal scrollback reset.
• No input broadcast yet. If you rely on iTerm2’s “send keystrokes to all panes in tab” for cluster administration, Rex does not have an equivalent built in yet.
• Windows and Linux desktop clients are still in the queue. Linux and FreeBSD servers are available now, while the Windows client (which Alasdair Monk previewed in early November) and the Linux desktop app are still in internal testing.

FAQ

Where Rex fits next to other multiplexers

Rex is a bet that your terminal emulator and your multiplexer should be one app, and that an AI agent should be able to script every split, tab, and status badge the same way a human does. If you want an open-source agent control plane that runs inside the terminal you already use, check out my Herdr review and Herdr app gallery. If you want a server-owned workspace with native non-terminal blocks (Git graph, SQLite, Kanban) across macOS, Linux, and Windows, read my Tern hands-on. And if you want the full landscape side by side, see the best terminal multiplexers comparison.