Claude Code on your phone: every honest route

First decide where Claude Code will run

There is no useful standalone Claude Code CLI on iOS. The CLI expects a repository, git, toolchains, long-lived processes, a real terminal, and access to the filesystem it changes. Android can provide a more Unix-like environment, but a production repository and full toolchain still belong on stable compute. Treat the phone as its controller.

Three questions expose the trade: what happens when the phone changes networks, the host sleeps, or the controller is suspended? SSH can reconnect; tmux keeps the process; mosh preserves a roaming terminal; cloud keeps the compute. A control plane can reconnect to a session, but cannot make a sleeping local host execute code.

Route one: SSH from a phone

SSH is the universal answer because Claude Code is a terminal application. Connect a mobile client to the repository host, change to the project root, and run claude. You get the same prompts, commands, transcript, and shell output as on a laptop.

# from the phone
ssh devbox

# on the host
cd ~/code/app
tmux new -As claude-app
claude

# detach without stopping Claude Code: Ctrl-b, then d

Do not expose password-authenticated SSH to the public internet. Use a key in the phone’s secure credential store, disable password login where practical, patch the host, and restrict the reachable user. The Claude Code over SSH guide covers headless login, token handling, server configuration, and latency.

Add tmux, then add mosh when the network moves

tmux is the first addition, not an optional refinement. It moves ownership of the terminal session from the phone connection to a process on the host. When iOS suspends the SSH client, cellular coverage disappears, or the phone changes networks, Claude Code keeps running inside tmux. The next connection attaches to the same pane and the same process.

tmux new -As claude-auth

# later, from any client
tmux attach -t claude-auth

# list everything running
tmux list-sessions

Mosh solves the next layer. It is an interactive remote shell designed for roaming, intermittent connectivity, and local echo. The client authenticates through SSH, then the session uses its own UDP transport and follows the phone when its IP changes. Typing feels immediate on a high-latency link because the client predicts local echo, and a brief dead zone produces an explicit stale-state warning instead of a frozen terminal that looks current.

Mosh does not replace tmux. If the mosh client is killed or the server process exits, tmux is what still owns Claude Code. It also does not provide SSH port forwarding or file transfer, and the server needs an allowed UDP port range. The robust stack is therefore mosh for the moving display, tmux for process persistence, and ordinary SSH for bootstrap, forwarding, or recovery.

Tailscale makes the host private and reachable

Tailscale is the network layer in this stack. Install it on the phone and the host, put both devices in the same tailnet, and connect to the host’s stable MagicDNS name or tailnet address. You do not forward port 22 through the router, track a home IP, or expose a development Mac to internet-wide scans. Access policy decides which identity can reach which machine.

Host: dev-mac
Address: dev-mac.your-tailnet.ts.net
User: agent
Key: phone-specific Ed25519 key

ssh agent@dev-mac.your-tailnet.ts.net

Tailscale does not keep Claude Code alive, render a terminal, or replace authentication. It provides a private route. You still choose OpenSSH or Tailscale SSH, still need tmux for a durable process, and still need mosh if you want a roaming terminal rather than repeated SSH reconnects. This distinction prevents a common setup failure: installing Tailscale, closing the phone client, and expecting the shell process to survive.

Use a dedicated device identity and remove it when the phone is lost. Restrict the development host in the tailnet policy rather than relying on the default allow-all policy once more people or devices join. If the repository contains production credentials, a private network is only one control; the phone credential, host user permissions, Claude Code permissions, and repository secrets remain separate boundaries.

Anthropic Remote Control is the direct Claude answer

Anthropic ships a phone-native route for Claude Code itself. Start server mode with claude remote-control, start an ordinary interactive session with claude --remote-control, or run /remote-control inside an existing session. The session appears at claude.ai/code and in the Claude app for iOS and Android, where the phone can read the conversation, send messages, answer questions, and follow subagent or workflow progress.

# server mode: start and manage remote sessions
claude remote-control

# one interactive local session that is also remotely visible
claude --remote-control "payments migration"

# from inside a session already running
/remote-control payments migration

Execution and filesystem access remain on the host, including local tools, MCP servers, configuration, and untracked files. The host makes outbound HTTPS connections to Anthropic on port 443 and opens no inbound port. That is materially simpler than exposing SSH. The transcript, messages, responses, and tool activity are stored on Anthropic’s servers while connected so state can synchronize across devices. This is not the same data boundary as a terminal that stays inside your tailnet.

Remote Control requires an eligible claude.ai subscription login. API-key authentication is not supported, and Team or Enterprise owners may need to enable the organization setting. It does not work through Bedrock, Google Cloud Agent Platform, Microsoft Foundry, or a custom ANTHROPIC_BASE_URL. The local process must remain alive, and an extended host network outage can end the session. Run it inside tmux when it is hosted through SSH.

Remote Control is the most direct answer when there is one Claude Code session and you want the official mobile conversation rather than a tiny terminal. It also supports mobile push when a long task finishes or needs a decision. It is not a fleet dashboard across Codex, Cursor, or several provider accounts, and it does not change the fact that each concurrent writing session needs an isolated worktree.

Web-based approaches are two different architectures

“Claude Code in a browser” can mean an Anthropic cloud session or a browser terminal pointed at your own machine. They share a screen shape and almost nothing else.

Claude Code on the web is the low-setup cloud option. Start from claude.ai/code or the Claude mobile app, or dispatch from a terminal. Anthropic provisions a fresh VM, clones the GitHub repository, and keeps the task available after your laptop closes. That isolation is useful for unattended work. The cost is environment distance: the VM does not automatically have your local database, untracked files, private services, or uncommitted state from the normal GitHub path. The existing Claude Code web guide covers cloud environments, GitHub access, handoff, and limitations.

A self-hosted web terminal such as a browser shell gateway wraps SSH-like access in HTTPS. It can be convenient on a locked-down device that cannot install an SSH client, but it creates a high-value web endpoint capable of running commands. Put it behind strong identity, TLS, short sessions, origin checks, and a private network; do not publish an unauthenticated shell on a convenient URL. You also inherit terminal emulation, clipboard, resize, idle timeout, audit, and patching work that a mature SSH client already solved.

Continuum turns the phone into a fleet workbench

Continuum’s native iPhone app takes a different unit of control: not one vendor conversation, but the session fleet. The agent process runs on a paired Mac, an enrolled Linux or Windows host, or an entitled runner. The phone selects the repository, provider, model, and effort, creates the session, and then opens the same session identity visible on Mac and web.

The published iPhone surface has six session tabs: Chat, Plan, Diff, PR, Terminal, and Files. Chat streams the transcript and sends follow-ups. Plan holds the edit gate until you approve. Diff renders changes by file and hunk for reading. PR shows live GitHub state and a merge action. Terminal is a real remote PTY with mobile keys, and Files previews artifacts the agent wrote. The phone can also interrupt a turn or change the model and effort mid-session.

The honest review boundary is stated on the product page: the phone is for reading and deciding. Per-hunk staging and long-form code editing stay on desktop. That is the correct limit for a small screen. A merge button is useful only after the diff is understandable; it is not a reason to approve code you would have inspected more carefully at a desk.

The differentiator is breadth. The same iPhone workbench controls Claude Code, Codex, Cursor, Gemini, Grok, and OpenCode sessions supported by the host, rather than only Claude. It also shows live provider limits and fleet progress. Conductor is the closest worktree-oriented desktop comparison: its established local app is macOS-first, its current pricing page lists a mobile app as “coming very soon,” and its paid cloud workspaces run in Vercel Sandbox. Continuum’s current site claims the native iPhone control surface as shipped, not announced.

Notifications and limits change the mobile workflow

Anthropic Remote Control can push when a long-running task finishes or needs a decision, subject to its settings and the mobile notification permission. Continuum’s site claims turn-complete and plan-attention pushes that identify the session and repository, plus Live Activities and widgets for active session count and provider limits. Those are different signals: a completion notification routes attention, while a 5-hour or weekly gauge tells you whether starting another parallel run is sensible.

Security depends on which route you chose

Remote control expands the credential boundary. A phone that can send a prompt to an agent can cause that agent to read files, run commands, call MCP tools, and change a branch within its existing permissions. Protect the controller as seriously as the development machine: device passcode and biometrics, short credential lifetime where available, remote wipe, and immediate revoke when the device is lost.

Keep agent permissions conservative regardless of transport. A safe tunnel carrying an overpowered session is still an overpowered session. Use plan mode for broad work, keep destructive commands behind confirmation, isolate concurrent writers in worktrees, and reserve production credentials for tasks that explicitly need them. On a shared host, use a dedicated OS account and keep personal SSH keys, browser profiles, and cloud credentials outside its reach.

Choose the least complicated route that fits

Start with SSH and tmux if you already operate a reachable host. Add Tailscale when public reachability is the problem and mosh when roaming is the problem. Use Remote Control when the terminal itself is the problem and Claude-only scope is acceptable. Use a cloud session when host uptime is the problem. Use Continuum when the unit you need to control is the fleet rather than one shell.

The right setup is the one you can explain under pressure. If you know where the agent runs, what keeps it alive, which credential the phone holds, where the transcript travels, and how to revoke access, then controlling Claude Code remotely is ordinary operations rather than a trick.

Questions people ask

Keep reading