How to turn your phone into a Codex control center??
At first glance, it looks like a way to check on a Codex task from your phone. That is useful, but it misses the bigger idea. The power of Codex Mobile is that it lets you start, direct, review, and organize work running on your development machines without pretending that a mobile device should be a tiny terminal.
Over the last month, we have added a surprising amount of depth to that loop: worktrees, goals, side chats, inline code review, queued and steering prompts, attachments, skills and plugins, archived threads, and a long tail of small details that make the app useful for serious work.
This is the field guide I wish every new power user had. This is various notes, tips and tricks I collected over my 2 months at OpenAI and how I work with Codex and especially Codex Mobile.
The right mental model: your phone is the control center
The task, codex run and the code still runs where it belongs: on your Mac, Windows machine, devbox, or other connected host. Codex Mobile gives you a native interface for controlling that work.
You can setup as a host any macOS or Windows machine that can run the Codex Desktop app or the Codex CLI, more information on how to setup on our documentation page: https://developers.openai.com/codex/remote-connections
Start the task with the right boundaries
Good agent work starts with a correctly scoped environment. Codex Mobile lets you choose the connected host and workspace before the first prompt. For a new thread, you can also choose a branch, create a separate worktree, and run the environment setup associated with it.
That makes a few useful patterns possible, right from your phone:
-
Use the current checkout for a quick investigation.
-
Create a new worktree for a change that should stay isolated.
-
Start from the intended base branch instead of fixing Git state later.
-
Let the environment setup run before asking Codex to build or test.
Yes that's right, as of our latest version, you can now access the same environment scripts that you setup in your desktop Codex app on mobile. Meaning if you create a worktree, you'll see the environment listed and this script will be executed once the worktree is created.
Environments is a powerful feature of the Codex desktop app, you can read more about it here: https://developers.openai.com/codex/app/local-environments
Note: You can't yet edit those scripts from Codex Mobile
Use side chats as a branch of thought
https://developers.openai.com/codex/changelog?type=codex-mobile
Long-running coding threads accumulate valuable context. Interrupting one with every side question makes the main transcript noisy and can pull the agent away from the objective.
That is what side chats solve.
Use /side to open a lightweight conversation connected to the current thread. Use /side <prompt> to open it with a question already prepared. Even better, select text in the transcript and choose Ask in side chat. The selected passage becomes the starting context for the new conversation.
I use side chats for questions such as:
-
Why did Codex choose this architecture?
-
What does this error actually mean?
-
Is this behavior consistent with the desktop app?
-
Give me a release-note version of this implementation detail.
-
What should I verify before I approve this command?
The distinction is useful: the main thread owns the work; the side chat helps me understand the work.
This work on both the desktop and mobile apps, we're still refining the UX around them as we learn more about our and your use of them.
Use Plan for the path and Goal for the outcome
The mobile app come with full featured /goal and /plan supports, the app will shows you the plan tool questions and also the UI for /goal where you can see for how long it's been running, edit, pause it, etc...
Plan mode and goals solve different problems.
Plan mode asks Codex to propose the implementation path before changing code. It is useful when the task is underspecified, risky, or likely to touch several systems.
A goal is durable. It tells Codex what outcome to keep pursuing across turns. On mobile, /goal can create and manage that objective, while progress remains visible as the work continues.
A practical pattern is:
-
Start with Plan mode for a risky change.
-
Inspect the proposed boundaries.
-
Turn the accepted outcome into a goal when the work will require multiple iterations.
-
Let Codex continue through implementation, tests, review feedback, and cleanup without restating the objective every time.
But to tell you the truth, most of the time you don't even need to use plan mode directly. Just talk to Codex for a while about a given problem and once you're happy about the implementation details, ask Codex to set it as a goal.
Codex is better than us at writing goal, so it's often a good idea to let it write them for you.
Plans answer “how should we approach this?” Goals answer “what must be true before we are done?”
The important thing to remember when using goal: set a verifiable end state that is not too broad. If you tell Codex "do it 100% like x or Y" it'll probably often wants to go too far and waste some tokens.
But now that you can oversee your tokens from your phone, this is not a big problem anymore, right?
It's YOUR phone!
One of the things you might forget is that you're working from your phone. And we built in the composer all the tools you need to access your local phone data!
You can attach a photo, take a picture, browse your files, record a prompt, and more!
This might seem stupid to put that way, but remembering you're on your phone unlocks a lot of powerful flows, especially if you're working on a mobile native or web app.
For example, while working on ChatGPT iOS, whenever I see an issue, I often directly take a screenshot and send it to a task for a quick fix. I don't have to walk back on my computer, etc...
Even better, if I'm at home, on the same Wi-Fi, I can build & run the app directly on my device to test the outcome of a Codex thread directly.
Another thing you can do is start a prompt recording in the foreground and continue it in the background!
I also have a few long running pinned threads, one if a Linear tracker where I can quickly send any piece of text and because of the thread current context, it'll correctly add and tag the issue with the right project and labels.
Review code without leaving the conversation
Completed turns can show a summary of changed files. From there you can open the diff, inspect individual files, expand or collapse sections, wrap long lines, and open a source file with syntax highlighting. You can attach inline comments to the relevant lines and send that review context back to Codex.
There are several levels to the workflow:
-
Open the changed-file summary for a quick sanity check.
-
Tap through to the full source when a diff lacks surrounding context.
-
Add inline comments for precise corrections.
-
Use the review command to review local changes or compare against a branch.
-
Link a file back into the chat when you want Codex to reason about that file specifically.
The important point is not that a phone replaces a large monitor for deep code reading. It does not. The point is that many reviews are blocked on one or two decisions, and those decisions no longer need to wait until I am back at my desk.
Staying up to date
We're now keeping a changelog for the latest updates for Codex Mobile.
I also often post and demo our latest added features!
The larger lesson
The best mobile software does not shrink a desktop interface. It identifies the decisions that matter when you are away from the desk and makes those decisions fast, legible, and safe. And we're just getting started on that!
That is how I think about Codex Mobile now. It is where I can choose the right environment, set the objective, redirect a run, answer an approval, inspect the result, and keep the whole queue of engineering work coherent.
The computer still does the work. The phone keeps me in control.