TowCue
繁中

guide · TowCue Editorial Team

Codex Remote Workflow

Codex Remote Workflow: a practical TowCue review and decision guide.

Original editorial contentSources verifiedLast reviewed:

Quick answer

Codex Remote (GA since June 25, 2026) enables a new workflow: your computer runs Codex as a long-lived coding agent, while your phone becomes a supervision console. You start work on a Mac or Windows host (or an SSH-connected remote environment), then step away — reviewing diffs, approving commands, answering questions, and steering direction from the ChatGPT mobile app on iOS or Android.

Key constraint: The host machine must stay awake, online, signed in to the same ChatGPT account/workspace, and running the ChatGPT desktop app. Your phone is a control surface, not an execution environment. All code execution, file access, shell commands, credentials, MCP servers, and Computer Use happen on the host (or the SSH host it connects to).

Available to all paid ChatGPT plans (Plus, Pro, Business, Enterprise, Education). Free plan access is not documented as of August 2026.

The workflow shift

Traditional AI coding workflow: you sit at your computer, type prompts, watch the agent work, intervene when needed. The session ends when you close the laptop.

Codex Remote workflow: you start a task on your host machine, then leave. The agent keeps working. From your phone you can:

  • See live terminal output, screenshots, test results, and file diffs
  • Approve or reject shell commands and file writes
  • Send follow-up instructions or answer clarifying questions
  • Switch between multiple active Codex threads on the same host
  • Get notified when a task completes or needs attention

This shifts your role from operator (driving every step) to supervisor (setting direction, unblocking decisions, reviewing outcomes).

Architecture: host, phone, and the relay

┌─────────────────┐      Noise-encrypted relay       ┌─────────────────┐
│  Host Machine   │ ◄──────────────────────────────► │  Mobile Phone   │
│  (Mac/Windows)  │   OpenAI relay (no plaintext)    │  (iOS/Android)  │
│                 │                                  │                 │
│ • Repository    │   1. Phone sends: prompts,       │ • Prompts       │
│ • Shell         │      approvals, steering         │ • Approvals     │
│ • Credentials   │   2. Host returns: diffs,        │ • Steering      │
│ • MCP servers   │      terminal output, test       │ • Review        │
│ • Computer Use  │      results, screenshots        │ • Notifications │
│ • Plugins       │                                  │                 │
└─────────────────┘                                  └─────────────────┘

What the host provides (per OpenAI Remote docs):

  • Repository files and local documents
  • Shell command execution (sandboxed: Seatbelt on macOS, Bubblewrap on Linux)
  • Credentials, permissions, sandbox rules
  • MCP servers, skills, plugins, browser access, Computer Use
  • Signed-in websites and desktop apps accessible to the host

What the phone handles:

  • Natural-language prompts and follow-up instructions
  • Binary approvals (approve/reject/modify pending actions)
  • Steering decisions when the agent surfaces trade-offs
  • Review of diffs, test summaries, terminal output, screenshots
  • Switching between connected hosts and threads

The relay (OpenAI infrastructure) brokers the connection without decrypting application payloads. Your host never exposes ports to the public internet. Pairing is one-to-one: each phone–host pair requires a QR scan (or manual code for headless servers), bound to the same ChatGPT account and workspace.

Three host patterns

PatternUse caseProsCons
Personal host (your laptop)Ad-hoc supervision while awayZero setup; same env you already useMust stay awake/online; battery dependent
Dedicated host (always-on Mac mini / Windows box)Overnight/weekend long-running tasksPersistent availability; no laptop dependencyExtra hardware cost; setup maintenance
SSH remote environment (devbox, DigitalOcean Droplet, EC2, etc.)Heavy compute, different OS, team-shared envScalable compute; survives host sleep; policy-isolatedRequires SSH config; network latency; cloud cost

The desktop app auto-detects SSH hosts from ~/.ssh/config. You can also provision a DigitalOcean Droplet directly from the Codex app (first-party plugin, GA June 2026) — it handles SSH keys, droplet creation, and host registration.

Setup steps (from official docs)

  1. Host: Install latest ChatGPT desktop app (macOS or Windows). Sign in to your ChatGPT account/workspace.
  2. Host: Open Settings → Connections → Enable "Allow other devices to connect." A QR code appears.
  3. Phone: Update ChatGPT mobile app (iOS/Android). Open Remote tab, scan QR code.
  4. Both: Complete any MFA/SSO/passkey challenges. Verify same account/workspace.
  5. Test: From phone, start a simple task like "list the top 5 TODO comments in this repo".

Connections used since June 8, 2026 persist across updates. Older inactive connections require re-pairing after updating both apps.

Mobile-first supervision patterns

1. Start → leave → approve → review

"Before leaving for the office, you ask Codex to take on a refactor that will need time to work through, expecting to review the result when you get to your desk. Mid-commute, Codex finds two viable approaches and needs your direction before it can continue. From your phone, you review the tradeoffs, choose a path, and by the time you arrive, the task has kept moving in the direction you wanted." — OpenAI blog

2. Bug triage on the go

"Start investigating a bug while waiting for your coffee. Because Codex is running from your development environment, it can begin inspecting the relevant files, reproduce the issue in the browser, run tests, and begin working toward a fix. If Codex needs clarification or permission to continue, you can answer or approve from your phone." — OpenAI blog

3. Meeting prep synthesis

"You come out of back-to-back meetings to find a support issue evolving across Slack, email, documents, and browser-based tools, with a customer call coming up next. From your phone, you ask Codex to synthesize the latest updates, flag the key open questions, and prepare a concise briefing for the conversation." — OpenAI blog

4. Thread handoff (host ↔ host)

Move a running Codex thread between hosts — e.g., start on laptop, hand off to a DigitalOcean Droplet for overnight execution, hand back to laptop next morning. Requires matching Git repositories on both hosts. The handoff creates/reuses a worktree on the destination, preserving conversation state and goal progress.

What works well on mobile (and what doesn't)

ActionMobile suitabilityNotes
Approve/reject shell commandsHighBinary decision; context visible
Review file-level diff shapesMediumScan which files changed, line counts
Send follow-up steeringHighNatural language; no precision needed
Triage test failuresMediumRead output; decide retry vs investigate
Approve large multi-file refactorsLowDiff detail insufficient on phone screen
Review security-sensitive operationsLowRequires desktop scrutiny
Complex multi-file navigationLowScreen real estate limitation

Guideline: Treat mobile approvals as a triage layer, not final production sign-off. Configure your host to enforce guardrails (suggest mode, rollout budgets, hooks) regardless of where approvals originate.

Limitations and gotchas

  1. Host dependency: Host must stay awake, online, signed in, desktop app running. A sleeping laptop or dead battery ends the session. Dedicated/SSH hosts solve this.

  2. Setup not headless: Mobile pairing must start from the desktop app (Settings → Connections). Cannot be initiated from Codex CLI or IDE extension.

  3. Windows Computer Use: Requires foreground unlocked session. Remote control on Windows is best for starting/checking work while you dedicate the host desktop to the task.

  4. No standalone Remote API: OpenAI does not publish a public Remote API. Builders extend the host via skills, plugins, MCP servers, and authorized tools.

  5. Availability varies: By plan, role, workspace settings, app permissions, and rollout wave. Enterprise workspaces require admin to enable Remote Control access.

  6. Relay dependency: If OpenAI's relay is down, new mobile connections cannot be established (existing SSH sessions and direct WebSocket connections continue independently).

  7. Security model: Account compromise grants full host access (shell execution). Workspace-level SSO/MFA is a hard prerequisite for team deployments. Use hooks to enforce stricter policies for mobile-originated approvals (e.g., block rm -rf or git push --force when approval comes from mobile).

Enterprise governance considerations

For teams, Codex Remote introduces a split-brain model: intent originates on phone, execution on host/cloud, model calls route through gateway, approval happens on a different device. Recommended four-plane governance:

  1. Identity/Access plane: Workspace admin enables Remote Control; per-host allow connections; per-device QR pairing subject to MFA/SSO.
  2. Execution plane: Host-specific sandbox, network, secret policies. Cloud VMs need tighter isolation than personal laptops.
  3. Approval plane: Mobile approvals are first-class governance events. Log device metadata (which host, which phone, which user) via Codex hooks for audit trails.
  4. Cost plane: Model tokens, plugin actions, VM time, failed sessions must reconcile to user/project ledger. Unattended Droplets with active sessions accumulate charges until deleted.

Practical adoption checklist

  • Update both desktop and mobile apps to latest versions
  • Enable "Allow other devices to connect" on host; scan QR from phone
  • Test with a low-risk task (docs fix, test addition, TODO scan)
  • Configure suggest mode + approval policies on host
  • Define mobile-agent policies: which repos allow mobile approval, which require desktop review
  • For long tasks: set up dedicated host or SSH remote environment (DigitalOcean plugin or manual SSH config)
  • Enable "Keep computer awake" on personal host; verify power/network stability
  • For teams: enable workspace SSO/MFA; configure hooks to log mobile approval metadata; set rollout budgets

TowCue take

Codex Remote is not "coding on your phone." It is a supervision layer that decouples human decision-making from agent execution time. The meaningful shift is temporal: you no longer need to be present for the entire agent lifecycle — only for the judgment checkpoints.

For solo developers, this is convenience (unblock agents without opening laptop). For teams, it is a governance surface that splits intent, execution, and approval across devices and networks. The architecture (QR pairing, encrypted relay, host-bound execution) is deliberately conservative: no public ports, no credential leakage to mobile, existing sandbox/approval rules preserved.

Adopt incrementally: start with personal host + suggest mode + low-risk repos. Add dedicated/SSH hosts when task duration exceeds laptop battery life or when compute needs exceed local capacity. Define mobile-approval policies before the pattern spreads organically.

Verify current feature status, plan eligibility, and regional availability on the OpenAI Codex Remote docs before building team workflows around it.

Research sources

Research sources

No public source list is attached yet.

Related decision guides

guideHow to choose an AI tool for workguideHow to evaluate AI software pricingreviewTubeMagic ReviewupdateGemini Connected Apps August 2026