# Driving Agents from Your Phone: Remote Control, Happy, CloudCLI and Orca Mobile

URL: https://developertoolkit.ai/en/ecosystem/agent-tools/remote-mobile/
Description: Supervise Claude Code and Codex from a phone with Remote Control, codex remote-control, Happy, CloudCLI or Orca: setup, remote approvals, security, limits.

Remote and mobile clients steer a coding agent from a phone or browser while the agent keeps running on the developer's own machine. Claude Code ships Remote Control, Codex ships the experimental `codex remote-control`, Cursor's iOS app can reply to local agents, and Happy, CloudCLI, Orca and Nimbalyst add push notifications, remote approvals and multi-agent views.

This page is for the **developer** who starts a two-hour refactor at 4 p.m. and does not want to sit beside it, and the **tech lead** who decides which clients may touch company code. The agent stalls on a permission prompt the moment you leave the room, or it keeps going and you find a surprise in the diff the next morning. You need the agent to ask you, reach you wherever you are, and hand you evidence rather than a story.

## What you get from supervising agents on a phone

- **A decision table** that maps your agent, plan and network to the right client.
- **A worked example**: a permission request from `happy claude` approved on the phone.
- **A framework-level workflow**: plan at the desk, supervise from the phone, review at the desk.
- **Three copy-paste prompts** for the hand-off, the status check and the return review.
- **The security picture**: where each client relays traffic, what it stores, and how to turn it off.

How Claude Code's Remote Control and channels work in depth is on [channels and Remote Control](/en/claude-code/automate/channels-and-remote-control/). Running many agents at once from a desktop is on [agent shells](/en/ecosystem/agent-tools/agent-shells/).

## Which remote client fits your agent and setup?

Start from the agent you run and how it authenticates. The vendor's own path is the default; a third-party client earns its place with several agents, a gateway, or a full phone UI.

| Your situation | Pick | Why |
| -------------- | ---- | --- |
| Claude Code on a Pro, Max, Team or Enterprise login, talking to `api.anthropic.com` | **Remote Control** (`claude --remote-control`) | Built in; the Claude app and claude.ai/code connect to the local session; push notifications for permission prompts |
| Codex CLI on your machine | **`codex remote-control`** | Built into codex-cli; marked experimental in 0.157.1 and 0.162.1 (checked 2026-10-12) |
| Cursor with the Cursor iOS app | **Cursor for iOS** | See and reply to the local agents running on your computer from the app (Cursor changelog, 2026-10-06) |
| Claude Desktop user who wants to message a new task from the phone, not steer a running one | **Dispatch** in the Claude app | Pro and Max only; pair the mobile app with Claude Desktop; the task runs on your machine |
| Claude Code **and** Codex from one phone app | **Happy** | One wrapper for both agents, end-to-end encrypted, push when an agent needs permission |
| Claude Code behind an API key, a gateway, Bedrock, Google Cloud's Agent Platform or Foundry | **Happy** (test it first) | Remote Control is unavailable in all of these; Happy wraps the local CLI and relays through its own server |
| A full web UI on a phone or tablet: files, git, shell, every past session; includes Cursor CLI | **CloudCLI** | Self-hosted web UI on your machine; discovers existing sessions; all Claude Code tools disabled by default |
| You already run agents in parallel worktrees in a desktop app | **Orca** mobile companion or **Nimbalyst** iOS | The phone app pairs with the desktop app you already use |
| You found an old guide that uses Omnara as a phone remote | **None of the above: Omnara pivoted** | It is now a managed-agents platform; `pip install omnara` is a deprecated redirect |

**Popularity** (GitHub stars, read from each repository on 2026-09-26): Orca 78,410; Happy 23,913; CloudCLI 13,811; Omnara 2,870; Nimbalyst 1,777. Remote Control and `codex remote-control` ship inside the vendors' CLIs, so they have no star count. Stars measure attention, not whether a relay is safe for your code.

### Where does your code and transcript go?

Every option keeps execution on your machine. They differ in what crosses the network and who operates the relay, which is the first question security will ask.

| Client | Relay | What leaves your machine | Licence | Agents |
| ------ | ----- | ------------------------ | ------- | ------ |
| Remote Control | Anthropic API, outbound HTTPS only, no inbound ports | The session transcript (messages, responses, tool activity), stored on Anthropic servers under its data-usage policy | Part of Claude Code | Claude Code |
| `codex remote-control` | OpenAI's app-server remote control | Not stated in the `codex remote-control` help (0.157.1 and 0.162.1); OpenAI's Codex Remote docs described starting, guiding and reviewing tasks from the phone, and that page now redirects to "Codex on mobile" (checked 2026-10-12) | Part of codex-cli | Codex |
| Happy | Happy's sync server (default `https://api.cluster-fluster.com`), replaceable with `HAPPY_SERVER_URL` | End-to-end encrypted session data; keys stay on your devices | MIT | Claude Code, Codex, and others through ACP |
| CloudCLI (self-hosted) | None: the phone opens your machine's port | No third party sees it, but the server is a remote shell that listens on every network interface over plain HTTP (CloudCLI 1.37.3), so anyone on that network reaches its login page and can read the traffic | AGPL-3.0-or-later | Claude Code, Cursor CLI, Codex |
| Orca mobile | Orca's pairing relay (source in the repository's `cloud/` directory) | Agent status and the follow-ups you send | MIT | Whatever runs in Orca |
| Nimbalyst iOS | Not described in the README | Session status, questions and diffs, which the app shows | MIT | Codex, Claude Code, OpenCode and others |

None of these clients is an MCP server or a plugin, so none adds tool schemas to the agent's context window.

## Approve a permission from your phone with Happy

This example uses Happy because it works the same way for Claude Code and Codex. The commands come from the Happy README and the `happy` CLI README (npm `happy` 1.2.5, checked 2026-09-26).

1. Install the phone app (iOS App Store or Google Play, both linked from `github.com/slopus/happy`), or open the web app at `https://app.happy.engineering`.

2. Install the CLI on the machine where the agent runs. It needs Node.js 20 or later, and the agent's own CLI installed and logged in:

   **Claude Code**

   ```bash
   npm install -g happy     # not happy-coder, which is deprecated
   claude --version         # Claude Code must already work in this terminal
   ```

   **Codex**

   ```bash
   npm install -g happy     # not happy-coder, which is deprecated
   codex --version          # Codex must already be signed in
   ```

   **Cursor**

   The Happy CLI README (checked 2026-09-26) lists Claude Code, Codex, `agy`, OpenClaw and ACP-compatible agents, not Cursor CLI. For Cursor CLI sessions, use CloudCLI instead:

   ```bash
   npx @cloudcli-ai/cloudcli   # Node.js 22 or later; then open http://localhost:3001
   ```

3. Start the agent through the wrapper, in your repository, on a feature branch:

   ```bash
   git switch -c fix/flaky-invoice-tests
   happy claude --permission-mode default     # or: happy codex
   ```

   `--permission-mode default` pins Claude Code to Manual explicitly, so a change in Claude Code's starting mode (auto from v2.1.283, on both release channels on 2026-10-12) cannot silently turn phone approvals off. Happy 1.2.5 accepts the config value `default`, not `manual` (Happy 1.2.5 source, checked 2026-09-26). The session shows a QR code. Scan it with the Happy app to connect the phone. Happy authenticates with a key pair whose private key stays on the laptop; `happy auth login` and `happy auth logout` manage that sign-in.

4. Give the agent a task that will need approval, for example the hand-off prompt further down this page, and walk away.

5. When the agent asks for approval (Manual mode in Claude Code, the approval policy in Codex), Happy sends a push notification. Open it, read the exact command, and approve or deny it. Approve a bounded command such as `npm test -- invoices`; deny anything that pushes, deploys, deletes or touches files outside the repository.

6. Back at the laptop, press any key in the terminal. Control returns to the local session.

You should see the agent continue within seconds of your approval, and the phone show the same conversation as the terminal. If nothing arrives on the phone, run `happy doctor` on the laptop before you leave next time.

**Happy and agents without an approval surface**

Happy forwards only the permission requests an agent raises. Its `agy` backend runs one-shot and never prompts (Happy CLI README), so phone approval works for Claude Code and Codex, not `agy`.

## Start the vendor's own remote path

When your setup allows it, the built-in path is one less relay to review.

**Claude Code**

Remote Control requires a claude.ai login on Pro, Max, Team or Enterprise; on Team and Enterprise an Owner must first switch it on in the Claude Code admin settings. It is unavailable with API keys, Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, an enterprise Claude apps gateway, or an `ANTHROPIC_BASE_URL` that points anywhere other than `api.anthropic.com`. Run `claude` once in the project to accept the workspace trust dialog first.

```bash
# An interactive session you can also drive from the phone
claude --remote-control "invoice tests"      # alias: --rc

# Or server mode: several phone sessions, each in its own worktree
claude remote-control --spawn worktree --name "invoice tests"
```

Inside a running session, `/remote-control` (or `/rc`) connects the conversation you already have. Connect from the phone by scanning the QR code (in server mode, press the spacebar to show it) or by opening the session in the Claude app under **Code**. `/mobile` shows a QR code that leads to the app store.

For approvals on the phone, run `/config` and turn on **Push when actions required**. Permission prompts and questions stay open until you answer them. Other forwarded dialogs close after five minutes by default (`dialogExpiry` changes that).

`claude --help` in 2.1.283 and in 2.1.296 (checked 2026-10-12) does not list the `remote-control` subcommand, and on 2.1.283 `claude remote-control --help` errors unless you are signed in with an eligible account. The full flag list is on [channels and Remote Control](/en/claude-code/automate/channels-and-remote-control/).

**Codex**

`codex remote-control` manages the app-server daemon with remote control enabled. The CLI marks it experimental (checked on codex-cli 0.157.1 and 0.162.1):

```bash
codex remote-control start   # start the daemon with remote control enabled
codex remote-control pair    # print a short-lived manual pairing code
codex remote-control stop    # stop the daemon
```

Do not toggle the `remote_control` feature flag: `codex features list` shows it as `removed` in 0.157.1 and 0.162.1, and the behaviour is built in. Administrators can constrain the feature with `allow_remote_control` in a managed `requirements.toml`.

OpenAI's former Codex remote docs page now redirects to "Codex on mobile" (`learn.chatgpt.com/docs/mobile`, checked 2026-10-12). This page did not verify phone approvals for `codex remote-control`; if you need them, use `happy codex` from the previous section, which also covers Claude Code in the same app.

**Cursor**

Cursor for iOS is available on the Start, Pro, Pro+, Ultra, Teams and Enterprise plans, needs iOS or iPadOS 26.0 or later and English, and lists Android as planned; the docs page carries no beta label (cursor.com/docs/cloud-agent/mobile, checked 2026-10-12). Cursor's changelog entry of 2026-10-06, "Remote control for local agents", says you can now see and reply to the local agents running on your computer from the Cursor iOS app. The entry states: "Remote control doesn't move your agents anywhere" and "Remote control doesn't require cloud agents to work". It is on by default except in Enterprise organisations, where an admin turns it on under **Org settings > Security and identity > Remote control**, and a **Keep this computer awake** setting keeps the machine available. This page follows that changelog entry and has not tested phone approvals. For Cursor CLI sessions you can also use CloudCLI, which discovers them next to Claude Code and Codex ones.

```bash
npx @cloudcli-ai/cloudcli        # then open http://localhost:3001
```

From a phone on the same network, open `http://YOUR_LAPTOP_IP:3001`, where `YOUR_LAPTOP_IP` is the machine's address on that network. CloudCLI disables all Claude Code tools by default, because the web UI is a remote shell on your machine; turn on only what the task needs under the sidebar's gear icon. Cursor's cloud agents, which run away from your machine, are on [cloud agents and automations](/en/cursor-ide/automate/cloud-agents-automations/).

**CloudCLI is a remote shell on plain HTTP: trusted networks only**

CloudCLI 1.37.3 listens on every network interface (`0.0.0.0`) over unencrypted HTTP, and the first person to open it creates its single username-and-password account. Run it only on a network you trust, never on café, hotel or conference Wi-Fi, and create the account yourself the moment it starts. Anyone on the network can read the password and session token in transit. For access from outside, put the laptop and the phone on a private VPN instead of forwarding the port to the internet. When you only need the browser on the same laptop, start it with `HOST=127.0.0.1 npx @cloudcli-ai/cloudcli` so it listens on loopback alone.

If you already run agents in Orca or Nimbalyst, pair their phone apps instead of adding another tool; setup and a comparison are on [agent shells](/en/ecosystem/agent-tools/agent-shells/).

## Start at the desk, supervise from the phone, review at the desk

The phone is good at answering a question, approving a bounded action and redirecting a wandering agent. It is poor at reading a diff, so planning and review stay at the desk.

1. **Plan at the desk.** Write the task with a definition of done that a status line can prove: the exact test command, the files in scope, and what must not change. Put the [acceptance criteria](/en/workflows/plan/acceptance-criteria/) in the prompt, not in your head.

2. **Isolate the run.** Create a branch or a worktree for the task. With Remote Control server mode, `--spawn worktree` gives each phone session its own worktree; in Codex, see [worktrees](/en/codex/automate/worktrees/).

3. **Set the permission boundary before you leave.** Start the session in Manual mode (`claude --remote-control --permission-mode manual`, or `happy claude --permission-mode default`) so every command outside the allowlist becomes a phone prompt. From v2.1.283 (both release channels on 2026-10-12), auto mode is the starting mode, and its classifier approves actions without asking you. Do not start an unattended run with `--dangerously-skip-permissions` or a full-access mode; those belong only in a disposable, network-restricted [sandbox](/en/ecosystem/agent-tools/sandboxes/).

4. **Hand off with the prompt below**, confirm that one push reaches your phone, then leave. Close the lid only if the session runs in `tmux` or `screen` on a machine that stays awake.

5. **Supervise from the phone.** Answer questions, approve bounded commands, and ask for the status prompt when a push arrives. Deny pushes, merges, deploys and anything outside the repository, and say why so the agent can adapt.

6. **Review at the desk.** Run the return-review prompt, push the branch, and let CI and [agent PR review](/en/workflows/ship/agent-pr-review/) judge it. A human reviewer signs off on the pull request, as for any desk work.

## How do you prove phone-steered work is right?

The session has to produce evidence a status line can carry, and the desk checks it before anything ships.

| Check | Where | Pass condition |
| ----- | ----- | -------------- |
| **Done is defined** | Hand-off prompt | A named test command and a file scope, written before you leave |
| **Scope held** | Phone diff pane (Remote Control) or swipe-through diffs (Nimbalyst), then `git diff --stat` at the desk | Only the files in scope changed; no lockfile, CI config or unrelated module |
| **Tests pass** | Status reply, then rerun at the desk | The same command, exit code 0, run by you, not only reported by the agent |
| **Remote approvals are accounted for** | Return-review prompt | Every command you approved from the phone is listed with its result |
| **Gates pass** | CI on the pushed branch | Type check, lint, tests and review automation green; see the [evidence bundle](/en/workflows/ship/evidence-bundle/) |
| **A human signs off** | Pull request | The reviewer approves the evidence, not the agent's summary |

A bad run costs one `git reset` on the branch or one deleted worktree, because nothing was pushed or merged without review.

## Copy-paste prompts for phone-supervised agents

**Copy-paste prompt: hand-off before you leave the desk**

```text
I am leaving the desk and will supervise you from my phone.
Task: make the tests in tests/invoices/ pass reliably. They fail about one
run in five with a timeout in the PDF rendering step.
Rules for this session:
- Work only on the current branch. Commit locally after each green step.
  Never push, merge, deploy, or change CI config or lockfiles.
- Files in scope: src/invoices/** and tests/invoices/**. Ask before
  touching anything else.
- Done means: `npm test -- tests/invoices` passes 10 runs in a row.
  Run it with a loop and report the pass count.
- When you need a decision, ask one question with numbered options, so I
  can answer with a single digit.
- After each milestone, post a status of at most 80 words: what changed,
  the command you ran, its exit code, and what you will do next.
```

**Copy-paste prompt: status check from the phone**

```text
Status, in at most 100 words: 1) files changed since the branch point,
2) the last test command you ran and its exit code, 3) anything you are
blocked on, 4) your next step. If any file outside src/invoices/ or
tests/invoices/ changed, list it first and stop until I reply.
```

**Copy-paste prompt: return review at the desk**

```text
I am back at the desk. Before I push, produce an evidence summary:
1. `git log --oneline` since the branch point, and `git diff --stat`.
2. Rerun `npm test -- tests/invoices` 10 times and report the pass count.
3. Run the type check and the linter and report their exit codes.
4. List every command I approved while I was away and what it did.
5. List anything you assumed instead of asking, and any test you changed
   or skipped, with the reason.
Do not push. I will review this and push myself.
```

**Traps: remote-client commands and claims that look right and are not**

- **`npm i -g happy-coder`.** Deprecated on npm: "This package has been renamed to 'happy'". Install `happy`.
- **`pip install omnara` to control Claude Code from your phone.** PyPI `omnara` is a deprecated redirect, and Omnara is now a managed-agents platform used through `npx omnara`.
- **A `claude setup-token` token for Remote Control.** That token and `CLAUDE_CODE_OAUTH_TOKEN` can only make model requests; Remote Control needs a full-scope login from `claude auth login`.
- **`codex features enable remote_control`.** The flag is stage `removed` in codex-cli 0.157.1 and 0.162.1; use `codex remote-control start`.
- **"Crystal" as a current app.** It was deprecated in February 2026 and is now Nimbalyst.
- **CloudCLI as "just open source".** It is AGPL-3.0-or-later; clear it with legal before you host a modified copy for others.
- **"Remote Control only exposes the single active session".** CloudCLI's README FAQ says so, but server mode (`claude remote-control`) serves up to 32 sessions by default (`--capacity`); one session applies only to the interactive form (Claude Code 2.1.283 docs).

## What breaks when you drive agents from a phone?

- **"Remote Control requires claude.ai subscription auth".** An `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN` or `apiKeyHelper` outranks your login. Recovery: remove it from the shell and from the settings `env` block, then `claude auth login`. If the key must stay, use Happy instead.
- **"Remote Control is only available when using Claude via api.anthropic.com".** LiteLLM, OpenRouter, Claude Code Router, a corporate gateway, Bedrock, Google Cloud's Agent Platform or Foundry routes the session. Recovery: unset the variable the message names for this session, or use Happy; the gateway trade-offs are on [gateways and local models](/en/ecosystem/agent-tools/gateways-local-models/).
- **"Remote Control requires feature-flag evaluation".** `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` or `DISABLE_GROWTHBOOK` is set. Recovery: unset it. `claude doctor` names the eligibility check that failed. If the message names `DISABLE_TELEMETRY` or `DO_NOT_TRACK`, update to v2.1.283 or later (both release channels on 2026-10-12); until you do, unset them.
- **The session went offline when you closed the lid.** Recovery: run the agent inside `tmux` or `screen` on a machine that stays awake. To bring the conversation back, match how you started it. For an interactive `--remote-control` or `/remote-control` session, run `claude --continue` (or `claude --resume`), which reconnects Remote Control. For server mode, run `claude remote-control --continue` within about four hours of the server stopping; it cannot be combined with `--spawn` or `--capacity`.
- **Server mode exited during a train ride.** It gives up after roughly 10 minutes without network, while an interactive `--remote-control` session keeps retrying. Recovery: prefer the interactive form on flaky networks.
- **No push notification arrives.** For Remote Control, `/config` shows **No mobile registered** until the Claude app refreshes its token; iOS Focus modes and Android battery optimisation delay pushes. Recovery: open the app once, exempt it from battery optimisation, and test with a prompt such as "notify me when the tests finish". For Happy, run `happy doctor`.
- **The Happy daemon fails with "API Error: 401" after a reboot on macOS.** A `launchd` agent cannot reach the keychain. Recovery: start the daemon from your shell profile, as the Happy CLI README shows, not from a LaunchAgent.
- **The agent waits on a dialog the phone never shows, or a turn ends on its own.** The Fable usage-credits consent prompt appears only where the session runs; other forwarded dialogs (not permission prompts or questions) close after five minutes; `/plugin` and `/resume` are local-only. Recovery: pick the model and install plugins at the desk, set `dialogExpiry`, and run one trial prompt before you leave.
- **Two phone sessions edited the same file.** Remote Control server mode defaults to `--spawn same-dir`. Recovery: restart with `--spawn worktree`, or press `w` in the server terminal.
- **You approved something you should not have.** Recovery: stop the session, `git reset --hard` to the last good commit on the branch (or delete the worktree), and tighten the hand-off scope.

## What a tech lead should set before the team uses phone clients

A phone client is a new way to approve shell commands on company machines; decide it once for the team.

| Control | How | Effect |
| ------- | --- | ------ |
| Turn Remote Control off on a device or fleet | `disableRemoteControl` setting (managed settings for a fleet) | No session can be driven remotely |
| Allow Remote Control on Team or Enterprise | Owner toggle in the Claude Code admin settings | Off until an Owner enables it |
| Require a verified device | **Require trusted devices** (beta) under Organization settings, Capabilities, Remote sessions | Steering needs an enrolled device and a biometric or passkey sign-in no older than 18 hours |
| Keep a repository from auto-connecting | `remoteControlAtStartup: false` in the project's `.claude/settings.json` | Honoured; a project-level `true` is ignored, so a checked-in file cannot turn Remote Control on for everyone |
| Constrain Codex remote control | `allow_remote_control` in a managed `requirements.toml` | Admin-level limit for Codex |
| Keep phone approvals per command | `permissions.disableAutoMode: "disable"` in managed settings | Sessions start in Manual, so commands outside the allowlist reach the phone as prompts |
| Zero Data Retention organisations | Nothing to set | Remote Control cannot be enabled, because the transcript is stored on Anthropic servers |
| Third-party clients | An allowlist in your engineering policy | Review the relay, the licence (CloudCLI is AGPL) and the permission defaults first |

## Where to go next with remote and mobile agents

- [Channels and Remote Control](/en/claude-code/automate/channels-and-remote-control/): every Remote Control mode and flag, plus channels that push CI failures into a running session.
- [Agent shells](/en/ecosystem/agent-tools/agent-shells/): Orca, Nimbalyst and other desktop apps with phone companions.
- [Parallel agents](/en/ecosystem/agent-tools/parallel-agents/): several phone-supervised tasks without file conflicts.
- [Agent sandboxes compared](/en/ecosystem/agent-tools/sandboxes/): where an unattended run with wider permissions is safe.
- [Background agents](/en/workflows/automate/background-agents/): when a cloud run fits better than your machine.
- [Voice input](/en/ecosystem/agent-tools/voice-input/): dictating prompts on the move.
- [Agent tools overview](/en/ecosystem/agent-tools/): the other shelves, from multiplexers to review bots.
