How to use Codex from your phone

I like Codex a lot, but I don’t love the default ergonomics when a session runs longer than “one sitting”.

The moment you step away from your terminal, you usually lose the easy control loop:

check progress
send a clarifying instruction
approve a tool permission
review the changes

On a phone, you can brute-force it with SSH. I just don’t want my phone to be a tiny terminal.

Happier: gives me a way to keep Codex moving from my phone (follow-ups, approvals, diff review) while Codex still runs on my machine. Trade-off: you still need auth + the right backend path set up on the owning machine for the flows you care about (attach/resume, etc.).

TL;DR

Set up Happier (or attach via Direct sessions), then make sure Codex is authenticated on the owning machine (or connect via Happier connected services).
Start a Codex session from Happier (phone/web/desktop) and choose the machine that should run it.
From your phone, follow the transcript, send follow-ups, handle approvals, and review diffs.
When you want the terminal UI again, run happier attach <session-id> on the owning machine.
If the session goes inactive, resume is strict: it works only when the session is vendor-resumable on the current backend path.

The problem (in plain language)

Codex is good at doing work.

The friction is everything around it:

“Where is the session running?”
“How do I keep it moving while I’m not at my laptop?”
“How do I switch back to the terminal without forking the session?”

What I mean by “use Codex from your phone”

I don’t mean you’re running Codex on iOS.

I mean:

Codex runs on a machine you trust (laptop / server / dev box).
From your phone, you can monitor, steer, approve, and review.

That’s the only way this stays grounded: the repo and tools stay where they belong.

Authentication: get Codex logged in (without surprises)

Codex supports machine-local auth management in:

Settings → AI provider settings → Codex

From there you can:

see whether Codex is logged in on the selected machine
detect whether Happier picked up CLI login or OPENAI_API_KEY
open codex login directly inside Happier

You can also authenticate through Happier connected services:

subscription auth (device/paste flow)
or API key

CLI examples:

happier connect codex --device
happier connect codex --paste
happier connect codex --api-key

Backends: the part I kept tripping over with Codex

This is the Codex-specific nuance that took me a bit to internalize.

Codex can run through multiple backends in Happier:

Codex App Server (default): the path I’d recommend if you care about resumability and the app-first workflow.
Codex ACP: a fallback if you explicitly choose it.
Codex MCP: still fine for fresh sessions, but it’s not the normal vendor-resume path.

The two behaviors that matter in practice:

For new sessions, Happier defaults to App Server and doesn’t silently fall back if it’s unavailable.
For resume, Happier stays strict — it errors instead of quietly starting a fresh session.

Once I understood those two rules, Codex-from-phone stopped feeling “random.”

If you’re new to Happier (what it is, and where to get it)

If you haven’t seen Happier before: it’s an open-source companion app (mobile/web/desktop) for AI coding agents like Claude Code, Codex, and OpenCode.

The workflow here is: use Happier from your phone to monitor/steer/approve/review, while Codex still runs on the machine that owns the workspace.

For this guide, that means you can do the “session supervision” part of Codex (follow-ups, approvals, diff review) without living in SSH.

Get set up:

How to run Happier from your phone
GitHub: https://github.com/happier-dev/happier
Install/download: https://github.com/happier-dev/happier#how-it-works
Discord (community + support): https://discord.gg/W6Pb8KuHfg

Phone workflow: start a Codex session and keep it moving

1) Start the session from your phone

From your phone (app or mobile web UI):

create a new session
choose Codex
pick the machine that should run it
send your task

2) Use your phone for the supervision loop

From your phone you can:

read progress in the transcript
send follow-ups (“pause and explain what you changed”, “only touch these files”)
handle permission prompts depending on your mode
review diffs before you commit

3) Switch back to terminal (attach)

When you’re back at a laptop/terminal on the owning machine:

happier attach <session-id>

Codex supports an attach flow for app-started sessions:

start from Happier
later attach from terminal
switch into local control
optionally switch back to remote control

Resume inactive Codex sessions (what to expect)

Codex resume in Happier normally uses the default App Server path.

An inactive Codex session can be resumed when:

the session has valid Codex resume metadata
the current backend/machine combination supports resume (App Server by default, or ACP if explicitly selected)
any required machine dependency for the selected resume path is already installed

From CLI:

happier resume
# or
happier resume <session-id>

From phone/app/web:

inactive sessions accept input only if they’re resumable
sending a message triggers resume first

Permissions and modes (the short version)

If you’re getting blocked a lot on prompts:

start with Default
try Safe YOLO for less interruption
use YOLO intentionally, and review diffs afterwards

Troubleshooting

Symptom: Codex sessions won’t resume

Likely causes:

the session is on a backend path that doesn’t support vendor resume (common if you forced plain MCP)
required dependencies for the selected path aren’t installed

Fix:

prefer the default App Server path for resumable sessions
keep Codex authenticated and ready on the machine

Symptom: I can’t attach from the terminal

Likely causes:

you’re on a different machine than the one that owns the session
attach behavior differs by OS (tmux on Linux/macOS; Windows uses different host modes)

Fix:

run attach on the owning machine

FAQ

Is Codex continuity as stable as Claude?

It can work well, but the docs are explicit that Codex handoff/continuity is still less mature than Claude/OpenCode in some paths.

If you want the most stable cross-machine handoff today, prefer Claude/OpenCode; if you want Codex, keep auth and dependencies ready on the machines you care about.