Claude Code Remote Control: The Untethered Developer

Every Claude Code user knows this moment. You kick off a big refactor, watch the agent start chewing through files, and realize you need to be somewhere else. A meeting in ten minutes. Coffee ran out. Or honestly, you just don't want to sit at your desk for twenty minutes watching an agent restructure a service layer. The choice has always been the same: stay put or walk away blind.

Anthropic shipped Remote Control on February 25, 2026, and it kills that problem. It connects claude.ai/code or the Claude mobile app to a Claude Code session running on your machine. Your phone becomes a window into your local session. Everything keeps running locally---your filesystem, your MCP servers, your tools, your project config. The remote device is just a viewport.

I have been using it for a few days now, and it has changed how I physically relate to my dev environment in ways I didn't expect. This post covers what it is, how to set it up, the workflows I have found useful, and the limitations you should know about before getting excited.

What Remote Control actually is

Remote Control is not a cloud-hosted version of Claude Code. That already exists---Claude Code on the web runs on Anthropic's infrastructure. Remote Control does the opposite: your session stays local, and you get a remote interface to talk to it.

Here is what happens under the hood. When you start a Remote Control session, your local Claude Code instance registers with the Anthropic API and starts polling for work over outbound HTTPS. When you connect from another device, the server routes messages between the remote client and your local session over a streaming connection. No inbound ports open on your machine. No VPN. No port forwarding.

The practical result: your conversation stays in sync across every connected device. Send messages from your terminal, your browser, your phone---interchangeably. If your laptop sleeps or your network drops, it reconnects automatically when things come back.

This matters because local execution means your full environment stays available. MCP servers for database inspection, documentation search, project management? Still active. Your CLAUDE.md with project conventions? Still loaded. Local files the agent needs to read or modify? All there. Nothing moves to the cloud.

Getting started

Setup takes about thirty seconds.

What you need

You need a Max plan ($100/month or $200/month). Pro plan support is coming but has no confirmed date. API keys don't work. You also need to be logged in via /login and have accepted the workspace trust dialog by running claude in your project directory at least once.

New remote session

Navigate to your project directory and run:

claude remote-control

The process stays running in your terminal, showing a session URL and connection status. Press spacebar to show a QR code for your phone.

Two optional flags: --verbose for detailed logs, and --sandbox / --no-sandbox for filesystem and network isolation.

From an existing session

Already in the middle of something? Use the slash command:

/remote-control

Or the shorthand /rc. This carries your current conversation history over and shows the URL and QR code.

One tip that saves headaches: run /rename before /remote-control to give the session a descriptive name. When you have three sessions in your list, "auth refactor PR review" is much easier to find than "Remote Control session."

Connecting your device

Three ways to connect once the session is running:

1. Open the session URL in any browser (both commands display it in the terminal)
2. Scan the QR code with the Claude app for iOS or Android
3. Open claude.ai/code or the Claude app and find the session by name---active sessions show a computer icon with a green dot

Don't have the Claude app? Run /mobile inside Claude Code for a download QR code.

Enabling for all sessions

If you find yourself running /rc every single time, go to /config and set "Enable Remote Control for all sessions" to true. Then every session is automatically available remotely.

Workflow scenarios that actually matter

The setup is simple. The interesting question is how it changes the way you work. Here is what I have found useful so far.

The coffee break monitor

The simplest case and the one I use most. You start a big task---migration refactor, test suite expansion, multi-file restructuring---and then you leave. Before Remote Control, you either sat there watching or came back later hoping for the best. Neither was great.

Now it goes like this:

1. Start the task in your terminal
2. Run /rc
3. Scan the QR code with your phone
4. Walk away

From your phone you can watch the agent work, approve file changes when prompted, and send follow-up instructions. If Claude finishes the refactor and asks a clarifying question while you are making coffee, you answer from your phone and the session keeps moving.

This sounds small. But if you run three or four long tasks per day, each with five to ten minutes of dead time, you are getting back half an hour of desk-bound waiting. That adds up.

The couch reviewer

This is where I have gotten the most value. Start a code review at your desk:

Review the changes in the authentication refactor PR.
Focus on security implications and test coverage gaps.
Read the diff and provide a detailed assessment.

Run /rc, move to the couch, continue from your tablet or phone. The agent still has full access to your local repo---it can read files, check git history, run tests---while you are horizontal. This pairs well with the kind of review workflows I described in my Agent Teams post.

The multi-machine hop

Start a session on your desktop workstation, continue on your laptop in another room. The difference from just opening a new terminal elsewhere is that the session keeps full conversation context. The agent remembers everything---every file it read, every decision you made. You pick up exactly where you left off.

I use this when I want my desktop's horsepower for running builds and tests but prefer to work from the laptop for lighter tasks.

The meeting peek

This one requires some discretion. Start a long-running task before a meeting---generating tests, refactoring a service, auditing dependencies---and check on it from your phone during the meeting. If Claude needs input, a quick "looks good, now run the test suite" takes five seconds.

I would not recommend writing detailed architectural prompts during a standup. But glancing at progress and sending a one-liner? That is fine.

Remote Control vs Claude Code on the web

Both use the same claude.ai/code interface, so the distinction is worth understanding.

Aspect	Remote Control	Claude Code on the web
Execution	Your local machine	Anthropic cloud infrastructure
Filesystem	Your local files	Cloud-hosted repo clone
MCP servers	Your local MCP configuration	Not available
Project config	Full CLAUDE.md, settings, hooks	Limited to repo contents
Setup required	Terminal running locally	None
Parallel sessions	One per Claude Code instance	Multiple simultaneous
Best for	Continuing local work remotely	No-setup tasks, uncloned repos

Use Remote Control when you are in the middle of local work and want to keep going from another device. Your MCP servers stay active, your CLAUDE.md is loaded, your hooks work.

Use Claude Code on the web when you want to start fresh without any local setup, work on a repo you haven't cloned, or run multiple tasks in parallel.

If you rely on local tooling---Laravel Boost for database inspection, custom scripts, local test suites---Remote Control is the only option when you want to work away from your desk. The web version won't have your local environment.

Security model

The connection model is simple. Your machine makes outbound HTTPS connections to the Anthropic API. No inbound ports open. All traffic goes over TLS, same encryption as standard Claude Code sessions. The connection uses multiple short-lived credentials, each scoped to a single purpose and expiring independently---no long-lived token sitting around waiting to be compromised.

Your files stay on your machine. The remote interface sends messages through the Anthropic API, which routes them to your local session. File contents don't get stored in the cloud.

Bottom line: Remote Control doesn't introduce a meaningfully different security posture from using Claude Code normally. The only new surface is the streaming connection between your machine and the Anthropic API, and it uses the same protections.

If you want extra isolation, the --sandbox flag restricts what the agent can access on your local machine during the session.

Token management impact

Remote Control doesn't change how tokens are consumed. The session runs identically to a terminal-only session. But the ability to monitor from your phone does change the token management equation in one important way.

Without Remote Control, long-running tasks meant leaving the session unattended. You would come back to find the agent had burned through context exploring the wrong approach, and now you need to clear and restart. With Remote Control, you can course-correct in real time from your phone: "Stop. Wrong directory. Focus on src/services/ instead."

Fewer wasted tokens on misguided explorations. Fewer cleared sessions. It doesn't reduce the base cost of anything, but it cuts the waste from letting the agent run unsupervised.

Limitations worth knowing

Remote Control is a research preview. These are the constraints that matter right now.

The Max plan requirement is the big one. At $100/month minimum, this is not accessible to everyone. Pro plan support is listed as "coming soon" but there is no date. If you are on Pro, you are waiting.

One remote session per instance. If you use Agent Teams and run multiple Claude Code instances, each gets its own remote session, but you can't have two remote connections to the same instance.

Your terminal must stay open. Remote Control runs as a local process. Close the terminal or kill claude, and the session ends. Your machine needs to be running with the terminal alive for the duration. Closing the laptop lid is fine---it reconnects on wake. Killing the process is not.

Network timeouts happen after about ten minutes. If your machine is awake but can't reach the network for that long, the session dies and you need to start a new one. Brief drops and laptop sleep are handled gracefully, but extended outages are not.

No Team or Enterprise plans during the research preview.

For solo developers on Max plans, these limitations are manageable. The Pro plan expansion will be when this becomes broadly relevant.

Where this leaves us

I went into Remote Control expecting a minor convenience---check my phone instead of staring at my terminal. What I got was a change in how I think about when and where I can interact with my dev environment. The terminal stopped being a place I have to physically be.

Is it life-changing? No. It is a quality-of-life improvement that removes a specific friction point. But that friction point was one I hit multiple times every day, and now it is gone.

If you are on a Max plan and using Claude Code regularly, try claude remote-control once. Scan the QR code. Walk away from your desk. See how it feels to keep working from wherever you end up.

For more on building effective Claude Code workflows, check out my guides on token management, Laravel development workflows, and parallel development with Agent Teams.

---

Source: Claude Code Remote Control Documentation - Official Anthropic Documentation