# Claude Code Remote Control: Access and Control Sessions from Any Device

The average developer using Claude Code spends 20 hours per week in sessions, but until recently every one of those hours required sitting at the same terminal. Remote Control changes that constraint by bridging a running local session to any browser or the Claude mobile app, so your filesystem, MCP servers, and project configuration stay local while the conversation travels with you.

Source: https://fast.io/resources/claude-code-remote-guide/
Last reviewed: 2026-06-24

## Why Remote Sessions Change How You Work with Claude Code

The average Claude Code developer spends 20 hours per week inside the tool, and Claude Code now writes roughly 4% of all public GitHub commits. Those numbers reflect a workflow where the AI is a constant collaborator, not an occasional helper. But the default mode ties you to one terminal: close the lid, lose the session.

Claude Code Remote Control, released in research preview in early 2026, solves this by turning any browser or the Claude mobile app into a viewport for your local session. Your code, environment variables, MCP server connections, and project configuration all stay on your machine. The remote device is just a window into the running process, not a separate cloud environment.

This distinction matters. With VS Code Remote SSH or GitHub Codespaces, you move your development environment to a server. With Remote Control, the environment stays put. Your phone sends messages through the Anthropic API, and Claude Code on your machine executes them locally. No ports open inbound on your workstation. The connection uses outbound HTTPS only, the same transport as a normal Claude Code session.

Three practical scenarios make this valuable: reviewing a long-running refactor from your phone while away from your desk, kicking off a test suite on your workstation and monitoring progress from a tablet, and collaborating with a teammate by sharing a session URL while you both watch Claude work. Each scenario keeps your full local context intact, including any [Fast.io MCP server](/storage-for-agents/) connections, private repositories, and custom tooling.

## How to Set Up Claude Code Remote Control

Remote Control requires Claude Code v2.1.51 or later, a Claude Pro, Max, Team, or Enterprise subscription, and OAuth authentication (API-key-only setups don't work). On Team and Enterprise plans, an admin must enable the Remote Control toggle in the Claude Code admin settings before anyone on the team can use it.

Check your version first:

```bash
claude --version
```

If you need to update, Claude Code auto-updates by default. Otherwise run `npm install -g @anthropic-ai/claude-code@latest`.

There are three ways to start a Remote Control session, each suited to different situations.

**Server mode** dedicates the terminal to accepting remote connections:

```bash
claude remote-control --name "My Project"
```

This prints a session URL and lets you press spacebar to show a QR code. The process stays running and waiting for connections. Server mode supports multiple concurrent sessions (up to 32 by default) and can isolate each session in its own git worktree with `--spawn worktree`.

**Interactive mode** gives you a normal terminal session that is also accessible remotely:

```bash
claude --remote-control
```

You can type locally and from the remote device simultaneously. Messages stay synchronized across all connected surfaces.

**On-the-fly upgrade** converts an existing session without losing context. Type `/remote-control` or `/rc` inside any running Claude Code session. Your full conversation history carries over, and a session URL appears immediately.

To make Remote Control activate automatically for every session, run `/config` inside Claude Code and enable "Enable Remote Control for all sessions." Each `claude` process registers one remote session. If you run multiple terminal instances, each gets its own session.

### Connecting from Another Device

Once a session is running, you have three connection paths.

Open the session URL directly in any browser. It lands you at claude.ai/code with the session already loaded. This works on laptops, tablets, and phones.

Scan the QR code from the Claude mobile app. In server mode, press spacebar to toggle the QR code display. In interactive mode, run `/remote-control` again to see the URL and QR code. Download the Claude app for [iOS](https://apps.apple.com/us/app/claude-by-anthropic/id6473753684) or [Android](https://play.google.com/store/apps/details?id=com.anthropic.claude) if you haven't already. Use the `/mobile` command inside Claude Code to show a download QR code.

Find the session in the Claude app's Code tab. Remote Control sessions display a computer icon with a green dot when the local process is online. Sessions are named from either the `--name` flag, your `/rename` command, or auto-generated from your hostname.

### Push Notifications on Mobile

With Claude Code v2.1.110 or later, Claude can send push notifications to your phone during Remote Control sessions. Claude decides when to push, typically when a long-running task finishes or when it needs a decision. You can also request it explicitly in your prompt: "notify me when the tests finish."

Set it up by installing the Claude app, signing in with the same account, accepting notification permissions, then running `/config` in Claude Code to enable "Push when Claude decides" or "Push when actions required."

## Running Claude Code on Remote Servers with Headless Mode

Remote Control connects a browser to your local machine. Headless mode solves a different problem: running Claude Code programmatically on a CI/CD server, cloud VM, or any machine without a terminal attached.

Pass `-p` with your prompt to run non-interactively:

```bash
claude -p "Run the test suite and fix any failures" \
  --allowedTools "Bash,Read,Edit"
```

Add `--bare` to skip loading hooks, skills, plugins, MCP servers, and CLAUDE.md files. This reduces startup time and makes behavior consistent across machines:

```bash
claude --bare -p "Summarize this file" --allowedTools "Read"
```

Headless mode accepts piped input, so you can feed data through standard Unix pipelines:

```bash
cat build-error.txt | claude -p "explain the root cause" > diagnosis.txt
```

For structured output in automation scripts, use `--output-format json` with optional `--json-schema` to enforce a specific response shape. The JSON response includes session ID, cost data, and the result:

```bash
claude -p "Extract function names from auth.py" \
  --output-format json \
  --json-schema '{"type":"object","properties":{"functions":{"type":"array","items":{"type":"string"}}}}'
```

You can chain sessions using `--continue` or `--resume` with a session ID. This lets you build multi-step automation where each step picks up where the previous one left off:

```bash
session_id=$(claude -p "Start a review" --output-format json | jq -r '.session_id')
claude -p "Continue that review" --resume "$session_id"
```

The two approaches serve different needs. Remote Control keeps a human in the loop across devices. Headless mode removes the human entirely, letting automation scripts drive Claude Code through API keys and structured output. Use Remote Control when you want to monitor and approve work from your phone; use headless mode when a CI runner should handle everything without intervention.

## Dev Containers for Isolated Remote Environments

Dev containers offer a third approach: running Claude Code inside a Docker container that provides a consistent environment for every team member. This matters for remote workflows because dev containers pair with cloud hosts like GitHub Codespaces, giving you a fully configured remote development environment without provisioning your own server.

Anthropic publishes an official Dev Container Feature for Claude Code. Adding it to your repository's dev container configuration installs Claude Code automatically when the container builds. Once inside, run `claude` in the terminal to authenticate and start working. See the [official dev container documentation](https://code.claude.com/docs/en/devcontainer) for the current setup steps and configuration options.

For teams, dev containers solve two problems that Remote Control and headless mode don't address. Environment consistency means every developer gets the same OS, dependencies, and tooling regardless of their local machine. Security isolation means commands Claude runs execute inside the container, not on the host. You can restrict network egress to only the domains Claude Code needs and configure unattended operation when the container is properly locked down.

Persistent authentication and organization-wide policy enforcement are both supported through container configuration. Teams can mount volumes to preserve login state across rebuilds and deploy managed settings that override individual developer preferences, ensuring consistent permissions and tool access across all sessions.

## Choosing the Right Remote Approach

Claude Code offers several remote access patterns, and picking the wrong one wastes setup time or limits what you can do. Here is a decision framework based on what you're trying to accomplish.

**Remote Control** is the right choice when you're in the middle of local work and want to keep going from another device. Your filesystem, MCP servers, and environment stay available. The local process must keep running, so pair it with `tmux` or `screen` if your machine might sleep. Network outages longer than about 10 minutes cause a timeout, but shorter interruptions reconnect automatically.

**Headless mode** (`claude -p`) is right for automation, CI/CD pipelines, and scripted workflows. It works with API keys, doesn't need a subscribed user watching, and outputs structured JSON for downstream processing. Use it when no human needs to interact with the session.

**Dev containers** are right for teams that need reproducible environments, security boundaries, or cloud-hosted workstations. They pair well with GitHub Codespaces for fully remote development without maintaining infrastructure.

**Dispatch** lets you message a task from the Claude mobile app to your desktop machine. It requires the Claude Desktop app and mobile pairing, making it simpler than Remote Control for one-off task delegation.

**Claude Code on the web** runs entirely on Anthropic's cloud infrastructure. Choose it when you don't have a local clone of the repo, want to run multiple tasks in parallel, or need zero local setup.

For teams storing project files, build artifacts, or agent output that needs to persist across sessions and devices, [Fast.io workspaces](https://fast.io/storage-for-agents/) provide a shared layer. Once Intelligence is enabled for the workspace, files are indexed for semantic search, so any team member or agent can query project documentation without manual organization. The [Fast.io MCP server](/storage-for-agents/) integrates directly with Claude Code, giving both local and remote sessions access to workspace files through a consolidated MCP toolset.

Local storage alternatives like S3 or Google Drive work for raw file storage. Fast.io adds the intelligence layer: upload a contract PDF, and any connected Claude Code session can answer questions about it with citations pulled from the file content. That capability persists whether you're accessing the session from your desk, your phone via Remote Control, or a headless CI runner.

## Troubleshooting Common Remote Control Issues

**"Remote Control requires a claude.ai subscription"** means you're authenticated with an API key instead of a claude.ai account. Run `claude auth login` and choose the claude.ai option. If `ANTHROPIC_API_KEY` is set in your environment, unset it first.

**"Remote Control requires a full-scope login token"** appears when you've authenticated with a long-lived token from `claude setup-token`. These tokens only support inference, not Remote Control. Run `claude auth login` for a full-scope session token.

**"Remote Control is disabled by your organization's policy"** has several causes. On Team and Enterprise plans, an admin must enable the Remote Control toggle at claude.ai/admin-settings/claude-code. If the toggle is grayed out, your organization's data retention configuration is incompatible with Remote Control, and you'll need to contact Anthropic support.

**Session disconnects when the laptop sleeps.** Remote Control sessions reconnect automatically when your machine wakes up, but if the machine is awake with no network for more than roughly 10 minutes, the session times out and the process exits. Run `claude remote-control` again to start a fresh session. For long-running unattended work, wrap the command in a `tmux` session so it survives terminal closures.

**Tool calls need approval from the remote device.** Every tool call still requires your confirmation during Remote Control. Claude can't edit files or run commands without your approval. Front-load detailed instructions and edge cases in your initial prompt to minimize back-and-forth when you're away from a keyboard.

**Session naming confusion on mobile.** Sessions auto-name from the last message if you don't set a name explicitly. Run `/rename your-session-name` before activating `/rc` to give the session a recognizable name you can find quickly in the Claude app's session list.

Run `claude doctor` to diagnose issues that don't produce a clear error message. It checks authentication, subscription status, feature flags, and network connectivity in one pass.

## Frequently asked questions

### How do I use Claude Code remotely?

Start a Remote Control session by running `claude remote-control` in server mode, `claude --remote-control` for interactive mode, or typing `/rc` inside an existing session. This generates a session URL you can open in any browser at claude.ai/code or the Claude mobile app. Your code runs locally while the remote device provides a synchronized chat interface.

### Can I access Claude Code from my phone?

Yes. Install the Claude app for iOS or Android and sign in with the same account you use for Claude Code. Once a Remote Control session is active, find it in the app's Code tab or scan the QR code displayed in your terminal. You can send messages, approve tool calls, and monitor progress from your phone.

### How do I run Claude Code on a remote server?

Use headless mode with `claude -p "your prompt"` to run non-interactively on any server. Add `--bare` to skip local configuration loading, and `--allowedTools` to pre-approve specific tools. For CI/CD, use `--output-format json` to get structured results. For persistent remote environments, install Claude Code in a dev container with the official Dev Container Feature.

### What is Claude Code Remote Control?

Remote Control is a research preview feature that connects claude.ai/code or the Claude mobile app to a Claude Code session running on your machine. It lets you continue coding tasks from any device without moving your environment to the cloud. All file operations, tool calls, and MCP server access remain local. The connection uses outbound HTTPS through the Anthropic API.

### Does Remote Control work with VS Code?

Yes. In the Claude Code VS Code extension (v2.1.79 or later), type `/remote-control` or `/rc` in the prompt box. A banner shows connection status, and you can click 'Open in browser' to access the session from another device. The VS Code extension doesn't display a QR code, but the session URL appears in the conversation.

### Is Remote Control available on free Claude plans?

No. Remote Control requires a Claude Pro, Max, Team, or Enterprise subscription. API-key-only authentication is not supported. You must authenticate through claude.ai using OAuth.

### Can multiple people connect to the same Remote Control session?

Server mode supports multiple concurrent sessions (up to 32 by default), but each session is a separate conversation. One interactive session supports connections from your terminal, browser, and phone simultaneously, with messages staying synchronized across all surfaces.

### How do I persist files across remote Claude Code sessions?

For local sessions, files persist on your machine's filesystem. For cloud or team workflows where files need to be accessible across devices and sessions, workspace platforms like Fast.io provide persistent storage with built-in AI indexing. The Fast.io MCP server connects directly to Claude Code, so any session, local or remote, can read and write workspace files.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.