How to control Claude Code from your phone in 2026: native remote, Orca, Tailscale, and tmux
A practical guide to running and monitoring Claude Code agentic sessions from your mobile device—covering the native /config remote control setting, the Orca open-source app, Tailscale + mosh + Termux, and classic tmux over SSH, with security notes for dangerous-permissions workflows.
Update — June 30, 2026: Cursor shipped a first-party iOS app with cloud agents, Live Activities, and PR merges — no DIY setup required. See Cursor for iOS launch (June 29). This guide still covers Claude Code mobile paths.
In June 2026, @mattshumer_ posted a simple question on X that resonated with 109,000 people:
"Is there a good way to control Claude Code on your computer (with dangerous permissions) from your phone, like Codex Mobile?"
The replies surfaced four distinct solutions, ranging from a one-click toggle inside Claude itself to a purpose-built open-source mobile app to a DIY terminal setup involving Tailscale, mosh, and Termux. This article walks through every option with setup instructions, trade-offs, and security guidance for the specific challenge of remotely supervising an AI agent that has been granted broad system permissions.
Why this matters: the agentic session problem
Claude Code's power multiplies when you let it run unattended. A typical workflow looks like this: you write a task prompt, grant broad permissions so Claude does not pause to ask for every file write or shell command, then wait while it works through a multi-step problem. The session might run for twenty minutes or an hour.
The problem is that you are rarely at your desk the entire time. You walk away to make coffee, take a meeting, or commute home—and when the session stalls on an ambiguous decision or hits an error it cannot resolve on its own, you have no way to see what happened or give it a nudge without returning to your computer.
Mobile control solves this. It lets you monitor progress, respond to interruptions, or kill a runaway session from wherever you are.
Option 1: Native Claude Code remote control (easiest, zero extra setup)
This is the method most people do not know exists, surfaced in the original thread by @tregoudeau.
How it works
Claude Code has a built-in remote control feature that bridges your desktop sessions to the Claude mobile app. When enabled, every Claude Code session running on your machine appears in the Claude iOS or Android app as a live, interactive session—exactly as if you were at your keyboard.
Setup steps
Open Claude Code on your desktop machine.
Type /config in the chat interface.
Find the Remote Control setting and toggle it on.
Open the Claude app on your iOS or Android device (sign in with the same Anthropic account).
Navigate to the Sessions view—your active Claude Code sessions appear here.
That is the entire setup. There are no ports to open, no servers to run, no accounts beyond your existing Anthropic subscription.
What you can do from mobile
Read the full conversation history and tool outputs
Send follow-up instructions or clarifications
Interrupt and redirect the agent mid-run
See real-time output as Claude executes shell commands and edits files
Trade-offs
Requires the Claude mobile app (first-party Anthropic)
Session visibility depends on your Anthropic account tier
Less useful if you need to run arbitrary terminal commands outside of what Claude Code surfaces
Best for: anyone already using Claude Code and the Claude mobile app who wants the fastest path to mobile monitoring.
Option 2: Orca — open-source, multi-agent mobile client
Orca (@orca_build on X) is an open-source iOS and Android app with 5,000+ GitHub stars that was purpose-built for running AI coding agents from mobile.
What makes it different
While the native Claude remote only surfaces Claude Code sessions, Orca treats multiple agents—Claude Code, OpenAI Codex, and Cursor—as equal citizens. If your workflow spans more than one AI agent, Orca gives you a single mobile interface for all of them.
Setup steps
Install Orca from the App Store or Google Play (or build from source at github.com/stablyai/orca).
Open Orca and add a new agent connection.
Select Claude Code from the agent list.
Follow the in-app prompts to authenticate with your Anthropic account and connect to your running Claude Code instance.
Your sessions appear in the Orca dashboard, where you can monitor output, send messages, and switch between agent types.
What you get
Unified view across Claude Code, Codex, and Cursor sessions
Community-driven release cadence (features ship faster than first-party apps)
Open source: you can audit the code and self-host if needed
Available on both iOS and Android
Trade-offs
Community-maintained, so stability may lag behind a first-party app
Setup requires connecting each agent type separately
Slightly more configuration than the native /config toggle
Best for: developers who use multiple AI agents and want one mobile app to rule them all, or anyone who prefers open-source tooling over first-party apps.
This approach, contributed by @nkeilar in the thread (who reportedly strapped their phone to their arm for around-the-house use), gives you a real Linux terminal to your dev machine from your phone. It is the most powerful option because you are not limited to what a Claude-specific app surfaces—you can read log files, run tests, check git status, or do anything else a terminal allows.
Components
Tailscale: creates an encrypted WireGuard mesh network so your dev machine is reachable from anywhere without exposing any ports to the internet
mosh: a mobile shell that handles the intermittent connectivity of mobile networks—if your connection drops (switching from Wi-Fi to LTE, locking your screen), mosh reconnects automatically and preserves your terminal state
Termux: a terminal emulator and Linux environment for Android; on iOS, use Blink Shell or a-Shell instead
Setup steps
On your dev machine:
Install Tailscale: curl -fsSL https://tailscale.com/install.sh | sh
Authenticate: tailscale up
Note your machine's Tailscale IP (visible at tailscale ip -4 or in the Tailscale dashboard)
Ensure your SSH server is running: sudo systemctl enable --now ssh
On your phone (Android with Termux):
Install Termux from F-Droid (not Google Play—the Play version is outdated)
Open Termux and install mosh: pkg install mosh
Install Tailscale for Android from the Play Store and authenticate with the same account
Connect to your dev machine: mosh <your-tailscale-ip>
On your phone (iOS):
Install Tailscale for iOS from the App Store
Install Blink Shell from the App Store (supports mosh natively)
In Blink, add a new host with your Tailscale IP and configure mosh as the connection type
Connect
The wrapper script trick
@nkeilar shared a practical refinement: write a small wrapper script on your dev machine that shows all running terminal sessions (tmux windows, Claude Code processes, etc.) in a numbered menu when you connect. That way, you SSH in on your phone and immediately pick up the session you care about rather than hunting for it.
Add bash ~/bin/mobile-menu.sh to the end of your .bashrc or .zshrc so it runs automatically on login.
Trade-offs
Most setup effort of any option (Tailscale account, mosh install, Termux/Blink configuration)
Requires your dev machine to be on and reachable
Small screen makes complex terminal work awkward, but readable for monitoring
Best for: developers who want full terminal access, not just Claude-specific session views, and are comfortable with SSH-based workflows.
Option 4: tmux over SSH (the classic approach)
Suggested by @matthoneycutt, this is the simplest version of the terminal approach: SSH into your dev machine from your phone and use tmux to manage sessions.
Why tmux is non-negotiable for mobile
Mobile connections are unreliable by nature. Without tmux (or screen), a dropped SSH connection kills every process running in that shell—including your Claude Code session. Tmux decouples your terminal sessions from the SSH connection. Sessions live on the server; you just attach and detach as your connectivity allows.
Setup steps
On your dev machine:
Install tmux: sudo apt install tmux or brew install tmux
Start a named session before running Claude Code: tmux new -s claude
Inside the session, launch Claude Code normally
Detach at any time with Ctrl-B D—Claude Code keeps running
From your phone:
Use any SSH client (Termius, Blink Shell on iOS; ConnectBot, Termux on Android)
SSH into your machine: ssh user@your-machine-ip
Reattach to the session: tmux attach -t claude
You are back in the session, with full scroll history, exactly where it left off
Combining with Tailscale
Without Tailscale (or a similar VPN), SSH over the open internet requires port forwarding on your router and exposes your SSH port to the world. Add Tailscale to this setup for the same benefit as Option 3: SSH only over the encrypted Tailscale network, no public port exposure.
Trade-offs
Requires you to plan ahead and start a tmux session before leaving your desk
No Claude-specific UI—everything is raw terminal output
Screen real estate on mobile is the main limitation
Best for: developers who already use tmux daily and want zero new tooling beyond an SSH client on their phone.
Comparison: which method to choose
Method
Setup effort
What you see
Works offline?
Multi-agent?
Native /config remote
Low (toggle in Claude Code)
Claude Code sessions only
No
No
Orca
Low-medium (app install + auth)
Claude Code, Codex, Cursor
No
Yes
Tailscale + mosh + Termux
High (multiple components)
Full terminal
No (needs machine)
Yes (any CLI tool)
tmux over SSH
Medium (tmux + SSH client)
Full terminal
No (needs machine)
Yes (any CLI tool)
Security considerations for dangerous-permissions sessions
All four methods give you remote access to a Claude Code session that may be running with broad system permissions. Here is what that means in practice and how to stay safe.
What dangerous permissions actually enables
When Claude Code runs without permission prompts, it can write to any file your user account can write to, execute arbitrary shell commands, make network requests, and install packages. A misunderstood instruction or a prompt injection through a file Claude reads can cause real damage in this mode.
Mitigations
Isolate the environment. Run Claude Code with dangerous permissions inside a Docker container, a VM, or a cloud sandbox rather than directly on your primary machine. A container limits what a runaway Claude session can reach even if it tries to escape its task scope.
Use a dedicated user account. On your dev machine, create a second Linux user with limited sudo access. Run Claude Code as that user. A mistake cannot affect your main user's files or credentials.
Keep sessions short and scoped. The longer a session runs unattended, the larger the blast radius if something goes wrong. Break large tasks into smaller checkpoints where you review output before continuing.
Rotate credentials after long sessions. If Claude Code had access to environment variables containing API keys or tokens during a long run, consider rotating those keys afterward—especially if the session involved reading unfamiliar files or repositories.
Tailscale over public SSH. Never expose your SSH port directly to the internet for remote Claude Code access. Use Tailscale or a similar zero-trust network so only your authenticated devices can reach the machine.
A note on the other options mentioned
The thread also surfaced two other approaches worth knowing about:
sharemyclau.de creates a shareable web URL for a Claude Code session. It is useful for async handoffs or showing a colleague what you are working on, but creates a publicly reachable endpoint for a session that may have dangerous permissions enabled. Treat any sharemyclau.de link as sensitive.
Dispatch is Anthropic's official product for orchestrating Claude Code tasks. Matt Shumer described it as not meeting his needs for this use case. It may be a better fit for team-level orchestration than for individual developer mobile monitoring.
Practical recommendation
Start with the native /config remote control if you already use the Claude mobile app. It requires no new software and covers the core use case—monitoring and directing an in-progress session—without any added complexity. If you find yourself wanting to run arbitrary terminal commands alongside Claude Code, add Tailscale and tmux to the mix. If you work across multiple agents, give Orca a look.
The right setup is the one you will actually use when you are away from your desk. A simple tmux session you check via SSH beats a more powerful solution that you never configured.
FAQ
Can I send messages to Claude Code from my phone mid-session?
Yes, with all four methods. The native remote and Orca surface a chat interface directly. The terminal methods (Tailscale + mosh, tmux over SSH) let you type into the Claude Code CLI directly, which accepts messages at any point during a running session.
Does the native remote control work when I am on a different Wi-Fi network?
Yes. The native remote control routes through Anthropic's infrastructure, so it works as long as both your desktop and phone have internet access—no direct network link between them is required.
What SSH client should I use on iPhone?
Blink Shell is the most capable option: it supports mosh natively, has a good on-screen keyboard, and is actively maintained. Termius is a good alternative with a more beginner-friendly interface.
Can I start a new Claude Code session from my phone, not just monitor an existing one?
With the terminal methods (Options 3 and 4), yes—you have a full shell, so you can cd to any project and run claude just as you would at your desk. The native remote and Orca currently focus on monitoring and directing existing sessions rather than initiating new ones from scratch.
Is mosh required, or can I use plain SSH with Tailscale?
Plain SSH over Tailscale works, but mosh is strongly recommended for mobile use. When your phone switches networks, plain SSH drops and you have to reconnect. Mosh automatically re-establishes the session within a few seconds without losing your place. The difference matters when you are monitoring a long Claude Code run.
Methods and app availability reflect the state of tooling as of June 17, 2026. Verify current installation steps against the official Orca repository at github.com/stablyai/orca and Tailscale documentation before setting up a new workflow.
