What You Will Learn

This guide walks you through every method of using Claude Code remotely — from Anthropic's official Remote Control feature to DIY SSH setups with tmux, mosh, and Tailscale. By the end, you will have a working mobile coding setup where you can kick off tasks on your desktop, leave your office, and keep full control from your phone.

Claude Code Remote Control: The Complete 2026 Guide

On February 25, 2026, Anthropic shipped Remote Control — the ability to kick off a coding task in your terminal, put your laptop in your bag, and keep full control from your phone. No VPN, no port forwarding, no third-party tools required. Source

But the official feature is only one part of the story. The developer community has built an entire ecosystem of mobile coding setups around Claude Code, ranging from simple SSH tunnels to sophisticated multi-tool workflows with push notifications and voice input. This guide covers all of them.

Part 1: Official Remote Control

What It Is

Remote Control is Anthropic's built-in feature for continuing Claude Code sessions across devices. It works by having your local Claude Code instance register with the Anthropic API as a server, then allowing authorized clients (your phone) to connect and control the session remotely. Source

How It Works Under the Hood

The security model is straightforward and conservative:

Your Desktop (Claude Code)          Anthropic API           Your Phone (Claude App)
        │                                │                          │
        ├──── Register session ──────────►│                          │
        │                                │                          │
        │◄─── Assign session URL ────────┤                          │
        │                                │                          │
        │     Display QR code            │                          │
        │                                │◄──── Scan QR / Auth ─────┤
        │                                │                          │
        │◄─── Route messages ────────────┤──── Route messages ─────►│
        │                                │                          │
        │     (All traffic over TLS)     │                          │

Key security properties:

• No inbound ports — your local machine makes outbound HTTPS requests only
• No direct connection — your phone never connects directly to your desktop
• TLS encryption — all traffic flows through the Anthropic API over TLS
• Session-scoped — each Remote Control session has a unique URL that expires

Source

Setup Steps

Step 1: Update Claude Code

Remote Control requires Claude Code v2.1.51 or later:

# Check your version
claude --version

# Update if needed
npm update -g @anthropic-ai/claude-code

Step 2: Start a Session

Begin working on your project normally:

cd ~/projects/my-app
claude

Step 3: Enable Remote Control

From within your Claude Code session, run:

/rc
# or
/remote-control

This starts the Remote Control server. Your terminal will display:

Remote Control active
Session URL: https://code.claude.com/rc/abc123-def456
Press [space] to show QR code
Press [q] to stop Remote Control

Step 4: Connect From Your Phone

Two options:

1. QR Code: Press spacebar in your terminal to display a QR code. Open the Claude app on your phone and scan it.
2. URL: Copy the session URL and open it in the Claude app on your phone.

Your phone now has full control of the Claude Code session. You can send messages, approve file changes, and review output — the conversation stays in sync across all connected devices. Source

Enabling Remote Control by Default

If you use Remote Control frequently, enable it for all sessions:

/mobile

This displays a QR code for installing the Claude app if you have not already, and toggles the setting "Enable Remote Control for all sessions" to true. Once enabled, every Claude Code session automatically starts in Remote Control mode. Source

Plan Requirements

Source

Limitations of Remote Control

• Requires Claude app — you cannot use a generic browser; the Claude mobile app is required
• Anthropic dependency — all traffic routes through Anthropic's servers; if their API is down, Remote Control is down
• No offline support — both devices must have internet connectivity
• Session timeout — inactive sessions eventually expire
• Single provider — only works with Claude models, not if you are using OpenCode or other multi-provider tools

Part 2: SSH + tmux + mosh (The DIY Approach)

For developers who want full terminal control, multi-provider support, or work on unreliable networks, the SSH-based approach is more robust. As developer Harper Reed wrote: "When figuring out how to use Claude Code on a phone, the obvious answer was to ssh into a computer from a phone and run claude." Source

Why Three Tools?

You need two different types of resilience:

• mosh handles the flaky mobile connection — WiFi to cellular transitions, dead zones, phone sleeping
• tmux handles session persistence — keeps the Claude Code session alive even when your phone disconnects entirely

Together they make mobile development actually viable. Source

Setting Up the Stack

Step 1: Install Tailscale (Private Networking)

Tailscale creates a private WireGuard mesh between your devices. No port forwarding, no router configuration, no firewall rules.

On your desktop:

# macOS
brew install tailscale

# Linux
curl -fsSL https://tailscale.com/install.sh | sh

# Start Tailscale
sudo tailscale up

On your phone:

• Install the Tailscale app from your app store
• Sign in with the same account
• Both devices are now on the same private network

Your desktop gets a Tailscale IP (something like 100.64.x.x) that your phone can reach directly, regardless of what WiFi or cellular network either device is on. Source

Step 2: Install tmux (Session Persistence)

tmux keeps your terminal sessions alive independently of your SSH connection. When your phone disconnects (screen lock, network switch, battery die), the tmux session keeps running.

# macOS
brew install tmux

# Ubuntu/Debian
sudo apt install tmux

Create a tmux configuration optimized for mobile use:

# ~/.tmux.conf

# Increase scrollback buffer
set -g history-limit 50000

# Enable mouse support (useful on mobile)
set -g mouse on

# Reduce escape-time for responsive mobile input
set -sg escape-time 10

# Status bar with useful info
set -g status-right '#H | %H:%M'

# Larger status bar for mobile readability
set -g status-style 'bg=colour235 fg=colour136'

Step 3: Install mosh (Connection Resilience)

mosh (Mobile Shell) uses UDP instead of TCP, which handles network transitions gracefully. When your phone switches from WiFi to cellular or goes through a tunnel, mosh reconnects automatically.

On your desktop:

# macOS
brew install mosh

# Ubuntu/Debian
sudo apt install mosh

On your phone:

• iOS: Install Blink Shell or Termius — both support mosh natively
• Android: Install JuiceSSH or Termux with mosh package

Step 4: Connect and Start Claude Code

From your phone's SSH client:

# Connect via mosh through Tailscale
mosh user@100.64.x.x

# Start or attach to a tmux session
tmux new-session -s claude
# or if session already exists:
tmux attach -t claude

# Launch Claude Code
cd ~/projects/my-app
claude

Now you have a Claude Code session that:

• Survives network switches (mosh)
• Survives phone disconnections (tmux)
• Is accessible from any device on your Tailscale network
• Works with any AI provider, not just Claude

Reconnecting After Disconnection

When you pick up your phone later:

# mosh will auto-reconnect if the session is still alive
# If mosh session died, start a new one:
mosh user@100.64.x.x

# Reattach to your tmux session
tmux attach -t claude

Your Claude Code session is exactly where you left it — same conversation, same working directory, same pending changes.

Part 3: Push Notifications with ntfy

The problem with both Remote Control and SSH setups: you have to keep checking your phone to see if Claude Code finished its task. The solution is push notifications.

What is ntfy?

ntfy is a simple, open-source push notification service. You can self-host it for privacy or use the public instance at ntfy.sh. Source

Self-Hosted ntfy with Tailscale

For maximum privacy, run ntfy on your desktop and access it through Tailscale:

# Install ntfy
brew install ntfy  # macOS
# or
sudo apt install ntfy  # Linux

# Start ntfy server (it listens on port 80 by default)
ntfy serve --listen-http :8090

Since your phone and desktop are on the same Tailscale network, your phone can reach ntfy at http://100.64.x.x:8090. No data leaves your private network.

Configuring Claude Code Hooks

Claude Code hooks let you trigger custom commands when certain events occur. Set up a hook to send a notification when Claude Code needs input:

// ~/.claude/settings.json
{
  "hooks": {
    "notification": {
      "command": "curl -s -d 'Claude Code needs your attention' http://100.64.x.x:8090/claude-code",
      "event": "stop"
    }
  }
}

Source

ntfy Mobile App Setup

1. Install the ntfy app on your phone (iOS or Android)
2. Add a subscription to the topic claude-code on your self-hosted server (http://100.64.x.x:8090/claude-code)
3. Enable push notifications for the topic

Now whenever Claude Code stops and needs input — whether it finished a task, hit an error, or needs approval — you get a push notification on your phone. No need to keep the terminal open or constantly check.

Advanced Notification Setup

For more context-rich notifications, you can include the last message from Claude Code:

#!/bin/bash
# ~/.claude/hooks/notify.sh

# Get the last few lines of Claude Code output
LAST_OUTPUT=$(tail -5 /tmp/claude-code-output.log 2>/dev/null || echo "Task completed")

# Send notification with context
curl -s \
  -H "Title: Claude Code" \
  -H "Priority: high" \
  -H "Tags: robot" \
  -d "$LAST_OUTPUT" \
  http://100.64.x.x:8090/claude-code

Source

Part 4: Happy Coder (Free Open-Source Alternative)

Happy Coder is a free, open-source tool that provides a web-based interface for controlling Claude Code remotely, with built-in push notifications and voice input. Source

Key Features

• Free and open source — no subscription required beyond your Claude Code plan
• Push notifications — built-in notification system, no ntfy setup needed
• Voice input — speak commands instead of typing on a small screen
• Multi-agent support — works with Codex alongside Claude Code
• Web-based — works in any mobile browser, no app installation required

Setup

# Install Happy Coder
npm install -g happy-coder

# Start the server
happy-coder start --port 3000

# Access from your phone via Tailscale
# http://100.64.x.x:3000

Happy Coder provides a mobile-optimized web interface that displays your Claude Code conversation, lets you send messages, and shows file changes — all through your browser.

Part 5: Complete Setup Comparison

Method Comparison Matrix

Recommended Setup by Use Case

Casual user (check on tasks occasionally): → Remote Control. One command, one QR scan, done.

Daily mobile coder (frequently code from phone): → SSH + tmux + mosh + ntfy. Maximum resilience and control.

Team lead (monitor multiple sessions): → Happy Coder. Web-based, supports multiple agents, built-in notifications.

Multi-provider developer (uses Claude, Codex, and local models): → SSH + tmux + mosh. Works with any tool that runs in a terminal.

Part 6: Advanced Configurations

Running Multiple Claude Code Sessions

With tmux, you can run multiple Claude Code sessions in parallel and switch between them:

# Create named sessions for different projects
tmux new-session -d -s project-api
tmux new-session -d -s project-frontend
tmux new-session -d -s project-tests

# In each session, navigate and start Claude Code
tmux send-keys -t project-api 'cd ~/projects/api && claude' C-m
tmux send-keys -t project-frontend 'cd ~/projects/frontend && claude' C-m
tmux send-keys -t project-tests 'cd ~/projects/tests && claude' C-m

# From your phone, switch between sessions
tmux switch-client -t project-api
tmux switch-client -t project-frontend

Headless Linux VM Setup

For teams that want a dedicated remote coding environment, Claude Code Remote Control works on headless Linux VMs via SSH + tmux. Source

# On your cloud VM (AWS, GCP, etc.)
# Install Claude Code
npm install -g @anthropic-ai/claude-code

# Start in a tmux session
tmux new-session -s remote-claude

# Launch Claude Code
claude

# Start Remote Control
/rc

Then scan the QR code from your phone. This gives you a powerful cloud-based development environment controlled entirely from mobile.

Combining Remote Control with SSH

You can use both methods together for maximum flexibility:

1. SSH + tmux for session persistence and full terminal access
2. Remote Control within the tmux session for the mobile-friendly chat interface

# SSH into your machine
mosh user@100.64.x.x

# Attach to tmux
tmux attach -t claude

# Inside the session, Claude Code is running
# Enable Remote Control for phone access
/rc

Now you have:

• tmux keeping the session alive
• mosh keeping the SSH connection stable
• Remote Control providing a polished mobile interface
• Full terminal access when you need it

Part 7: Building Apps While Mobile

The Mobile Development Workflow

The combination of Claude Code + remote access fundamentally changes when and where you can be productive. A practical workflow:

1. Morning commute: Review overnight CI results on your phone, kick off fix tasks via Remote Control
2. Lunch break: Check progress via ntfy notifications, approve or redirect changes
3. Evening: Pick up your laptop and the tmux session is exactly where you left it

When Mobile Coding Makes Sense

Mobile coding via Claude Code is best suited for:

• Task initiation — describe what you want built and let Claude Code work while you are away
• Code review — read diffs and approve changes from your phone
• Bug triage — investigate issues and point Claude Code at fixes
• Progress monitoring — check on long-running tasks

It is less suited for:

• Complex debugging — small screens make reading stack traces painful
• Visual work — CSS and layout tweaks need a full screen
• Large-scale refactoring — you want to review extensive changes on a proper monitor

Building with ZBuild from Anywhere

For developers who want to build and iterate on applications while mobile, platforms like ZBuild complement the remote Claude Code workflow. ZBuild provides a visual app builder that works well on tablets and can be paired with Claude Code for more complex backend logic — giving you a full-stack development capability that does not require a desktop workstation.

Part 8: Troubleshooting

Common Issues and Fixes

Problem: "Remote Control not available on your plan" Fix: Verify you are on Pro, Max, Team, or Enterprise. Free tier does not support Remote Control.

Problem: QR code does not scan Fix: Ensure your Claude app is updated to the latest version. Try the session URL directly instead of scanning.

Problem: mosh connection drops and does not reconnect Fix: Verify mosh-server is running on your desktop (which mosh-server). Check that Tailscale is connected on both devices. Ensure UDP port 60000-61000 is open if not using Tailscale.

Problem: tmux session shows blank screen after reconnecting Fix: Run tmux attach -t claude instead of creating a new session. If the session died, check if Claude Code crashed by reviewing ~/.claude/logs/.

Problem: ntfy notifications not arriving Fix: Verify the ntfy server is running (curl http://100.64.x.x:8090/health). Check the ntfy app subscription URL matches your server address. Ensure your phone's Tailscale connection is active.

Problem: Claude Code session expired while phone was disconnected Fix: This happens with Remote Control after extended inactivity. Use tmux-based setup for sessions that need to persist for hours. tmux sessions survive indefinitely regardless of client connections.

Problem: Typing is slow on mobile Fix: Use voice input (Happy Coder) or keep messages short and task-oriented. Alternatively, prepare prompts in a notes app and paste them into the terminal.

Part 9: Security Considerations

Remote Control Security

• All traffic is encrypted via TLS through Anthropic's API
• Session URLs are unique and expire after use
• No inbound ports are opened on your machine
• Your credentials and files never leave your machine (only Claude Code's text output is transmitted)

SSH Security Best Practices

When exposing SSH for mobile access:

# Use key-based authentication only (disable password auth)
# In /etc/ssh/sshd_config:
PasswordAuthentication no
PubkeyAuthentication yes

# Restrict SSH to Tailscale interface only
ListenAddress 100.64.x.x

# Use a non-standard port
Port 2222

Tailscale Security

Tailscale's WireGuard-based mesh network provides:

• End-to-end encryption between devices
• No data routing through Tailscale's servers (direct connections)
• MagicDNS for easy hostname resolution
• Access control lists (ACLs) for team setups

Conclusion

Using Claude Code remotely in 2026 ranges from dead simple (one /rc command) to fully customized (SSH + tmux + mosh + ntfy + Tailscale). The right setup depends on your workflow:

• Remote Control for quick mobile check-ins with zero setup
• SSH stack for developers who live in the terminal and need maximum resilience
• Happy Coder for a free, feature-rich middle ground

The practical impact is significant. Development is no longer tied to sitting at a desk with a laptop open. You can start a task, walk away, and stay in control. Whether you are building a side project, managing a team's codebase, or prototyping an app with ZBuild, mobile Claude Code access means your development workflow follows you, not the other way around.

Sources

• Claude Code Remote Control Documentation — Anthropic
• Remote Claude Code: Programming Like the Early 2000s — Harper Reed
• Claude Code from the Beach: mosh, tmux, and ntfy — Rogs
• Claude Code Remote Control: Code From Your Phone — Medium
• Claude Code on Your Phone — Builder.io
• Perfect Claude Code Notifications with Tailscale and ntfy — Felipe Elias
• 3 Ways to Run Claude Code from Your Phone — Zilliz
• Run Claude Code from Your iPhone — Pete Sena / Medium
• Claude Code Remote Control Launch Analysis — Blockchain News
• Remote Control on Headless Linux VM — GitHub Issue #29479
• Claude Code Mobile Setup with tmux and Bitvise — GitHub Gist
• How to Use Claude Code on Your Phone — FelloAI
• Claude Code Mobile Setup — Sealos Blog