Codex App: Worktrees, Automations and Your First Commit

The Codex app earns its place when you have two independent coding tasks to supervise: give each its own worktree, then review and commit the results separately. For developers already on a ChatGPT plan, its advantage is keeping parallel work visible; the CLI and IDE extension remain useful for terminal work and focused edits.

What the Codex App Is For

OpenAI Codex is most useful on the desktop when you are directing several pieces of repository work and need to inspect what each one changed. A thread, now called a chat in the documentation, holds the conversation around a task. A worktree gives that task a separate checkout of your Git repository, so its file edits do not land in your active checkout. The desktop interface brings those conversations and their results into view. OpenAI's app documentation, worktree documentation.

Verified against OpenAI's live documentation on 18 October 2026: the Codex app, features and quickstart URLs now lead to documentation for the ChatGPT desktop app. The current setup is to install that app and select Codex from the ChatGPT dropdown for software development. The download name has changed; Codex remains an explicitly documented choice. Official quickstart.

Think of the desktop workflow as separate workbenches attached to the same project archive. Each bench can hold a different unfinished job. You still decide which finished changes belong together. That distinction matters when a founder delegates a validation fix while a second chat updates setup documentation: the app makes both jobs easier to supervise, but the founder still owns the final product behavior.

App, Terminal or IDE: Choose Where You Want to Work

Choose the app when your problem is coordinating work; choose the terminal or editor when your attention already belongs there. These are different interfaces to Codex, with different workflow advantages.

The surface capabilities above come from the CLI, IDE, quickstart and scheduled-task documentation. The choice of best fit is an editorial judgment about where you will supervise the work.

For a developer whose normal loop is shell command, test output, diff, repeat, the CLI remains a sensible default. It can inspect and edit the repository, run local tools, and use codex exec in repeatable scripts. Start with the OpenAI Codex CLI setup guide if that describes your day.

Codex App vs VSCode Extension

The IDE extension is the easier starting point when the relevant code is already open in Visual Studio Code. It can use open files and selections, let you inspect changes beside the source, and delegate larger tasks to the cloud. Use the desktop app when switching between independent jobs becomes more important than staying beside one file. You can also use the app's Open control to inspect a worktree in your editor. IDE workflow, worktree controls.

Where Codex in ChatGPT Fits

In the current desktop app, ChatGPT and Codex are selections in the same interface. Select Codex for codebase context and developer tools. Cloud is a separate execution choice: the quickstart describes reusable Codex Cloud environments that you can use from the web, desktop or mobile. A local worktree does not become cloud-hosted just because you supervise it through the app. Current setup and cloud workflow.

Codex App Download and Sign-In

Start from OpenAI's documentation and choose the download for your operating system. The current app is documented for macOS, Windows and Linux, with Linux explicitly described as a preview. Official download and setup.

Codex App for Mac

The official app page labels its Mac download macOS (Apple Silicon). Install the downloaded app, open it and follow the sign-in flow. Use the requirements shown on that page for your machine rather than assuming every Mac architecture is supported. Mac download.

Windows

OpenAI provides a native Windows app. It can run the agent with PowerShell and the Windows sandbox, or use Windows Subsystem for Linux, the Linux environment available inside Windows. Choose the environment in which your repository's dependencies and tools already work. Merely opening the same folder from a different shell does not prove its build will succeed. Windows installation and configuration.

Codex App for Linux

Linux now has an official desktop preview. The guide covers Ubuntu, Debian, Fedora and Arch Linux, with packages for x64 and ARM64 processors. Native Wayland support is experimental. Check the supported distribution versions and package instructions in the Linux desktop guide before installing; availability does not mean every desktop configuration has identical support.

Sign In With Your ChatGPT Account or an API Key

For a developer who wants to use an existing ChatGPT allowance, choose Continue to sign in and complete the browser login. For API access, choose Sign in another way, enter your key and select Continue. Both methods support local Codex work in the desktop app. Authentication instructions.

Codex is included with ChatGPT Plus, Pro, Business, Enterprise and Edu; Free and Go have limited desktop access subject to rollout. Check OpenAI's current inclusion rules and our Codex pricing guide for the plan details.

An API key changes both billing and access. Usage goes to your OpenAI Platform account instead of your included ChatGPT plan allowance. Codex cloud requires ChatGPT sign-in, and API-key access excludes cloud features such as GitHub code review and Slack integration. Some OpenAI-curated plugins work with an API key, while plugins requiring unsupported connection flows may not. Do not treat a key as a way to retain every subscription feature. Authentication and feature differences.

The Features That Matter for Daily Development

The useful feature set is a loop: organize a task, isolate its files, prepare its environment, inspect the result and save the accepted change. These are the current documentation names to look for.

Projects and Chats

Projects and chats is the organizational layer. Give each distinct outcome its own chat, and keep related work under the relevant project. A local folder provides the files Codex can work on; a new chat alone does not guarantee a separate checkout. Select Worktree explicitly when you want independent edits. Feature overview, quickstart.

For a technical operator maintaining an internal application, “fix the CSV import” and “document the deployment process” are useful separate outcomes. “Improve everything” is harder to review because there is no clear stopping condition.

Git Worktrees

Git worktrees separate file checkouts while sharing the repository's Git history. This lets Codex work in the background without changing the files in your foreground checkout. Worktrees require a Git repository. Worktree mechanics.

The practical payoff is being able to examine a proposed fix without abandoning your current checkout. The limitation is equally practical: separate directories do not establish that the eventual changes are compatible. Two independently reasonable edits can still disagree about the same application behavior.

Local Environments and Integrated Terminal

Local environments define setup scripts and reusable actions for a project. Setup scripts can prepare dependencies when a worktree is created. The Integrated terminal lets you run project checks and Git operations inside the relevant checkout. These features turn a directory of source files into an environment you can validate. Local environments and built-in Git tools.

If a task works in your normal checkout but fails in a worktree, first check the setup. Dependencies and ignored local files may be missing. OpenAI documents .worktreeinclude for copying selected ignored setup files into local managed worktrees; include only what the task needs. Worktree setup.

Code Review and Built-In Git Tools

Code review gives you a diff, line-specific feedback and review scopes. The built-in Git tools let you stage or revert changes, commit, push a branch and create a pull request. A diff is the line-by-line record of what changed; staging selects the changes for the next commit. Review controls, Git controls.

The review pane reflects the checkout's Git state, including edits you made yourself. Last turn narrows the view to the latest assistant turn. Use that view to understand an agent's contribution, then inspect the full staged change before committing. Otherwise, unrelated work can travel with the fix.

Scheduled Tasks

Scheduled tasks is the current documentation name for automations, and Scheduled is the management view. A standalone task starts a fresh chat for each run; a schedule inside a chat reuses that conversation's context. Local tasks require the computer to be on, the desktop app to be running and the project to remain available. Scheduling documentation.

A useful first automation is a recurring report on changes that need a human decision. Run its prompt manually first, inspect the output, then schedule it. For a Git project, choose a worktree if the task may edit files and you want those changes separated from unfinished local work.

Skills and Plugins

Skills package reusable workflow instructions and resources; plugins distribute skills and connections to tools. Use them when you keep repeating the same repository procedure, such as a release checklist. They complement the project and worktree workflow, but do not remove the need to inspect its output. Official skills documentation.

First Session: Two Threads, Two Worktrees, Reviewed Commits

Use two small, independent tasks to learn the workflow. The example below pairs a validation fix with a documentation update. Replace the example bug with a small issue you can reproduce in your own project.

1. 1

   Open the repository and establish the starting point

   Open the desktop app, select Codex, and open your repository folder as a local project. Choose a Git repository with a build or test command you already understand. Inspect existing changes before starting; save unfinished work so you can distinguish it from the exercise.

   Ask Codex: “Explain how to run this project's tests and identify the validation code. Do not edit files yet.” Check its answer against the repository's own instructions.

2. 2

   Start the first chat in Worktree

   Start New chat in the project. Select Worktree beneath the composer and choose the starting branch. For a clean exercise, use the same known base branch for both tasks.

   Submit: “Fix the empty-name validation bug. Keep the change limited to validation and its regression test. Run the relevant checks, report their exact results, and leave the changes uncommitted.” Codex creates the worktree when you submit the prompt. Choose a local environment setup script if the project needs one.

3. 3

   Start the second chat in a separate Worktree

   Return to the project and start another New chat. Select Worktree again and choose the same base branch. Opening another conversation without making that selection is not the isolation step.

   Submit: “Update the setup documentation to match the existing install and test commands. Do not change application code or configuration. Check the commands against the repository and leave the changes uncommitted.” Keep this job independent of the unfinished validation fix.

4. 4

   Review each diff and request focused corrections

   Open each chat's review pane. Read the changed files and use Last turn when you need to isolate the latest assistant contribution. Then inspect the full changes for the task.

   For an extra review pass, type /review and choose Review uncommitted changes. This reports findings without editing the working tree. To request a correction, hover over the relevant diff line, select +, leave feedback, then send a follow-up message asking Codex to address it. Treat automated findings as leads to verify against the code.

5. 5

   Validate in the worktree and create a branch

   Run the repository's relevant tests, lint or build checks in that worktree's terminal. Confirm what actually ran and what remains unchecked. For the documentation job, verify that the described commands exist and match the project setup.

   Select Create branch here in the chat header to give each worktree its own named branch. Codex worktrees start with a detached HEAD by default, meaning the checkout initially points to a commit rather than a named branch. Separate branch names make the accepted work easier to keep and review later.

6. 6

   Stage the accepted changes and commit each task

   Use the review pane to stage only the files or hunks you have accepted. A hunk is a group of changed lines. Inspect Staged to confirm the next commit contains the intended task, then use the app's Commit or push control to create the commit. Choose the commit action; pushing is a separate decision.

   Repeat that review, staging and commit process for the other chat. You now have independently saved changes. Before combining them through your normal branch or pull-request process, check their combined behavior. If you want to continue in your usual checkout, use Hand off to move a chat to Local; Git does not allow the same branch to be checked out in both places at once.

The control names and sequence above follow OpenAI's worktree instructions, review instructions and built-in Git workflow. The proposed task boundaries are an editorial example.

What Is Overhyped About Parallel Coding

Parallel generation does not remove integration work. Worktrees keep separate edits from immediately overwriting the same files. They cannot guarantee that a validation change and a caller change agree about an API, or that two local development servers will use different ports. Treat isolation as a way to make work reviewable, then check the combined result.

An automation also does not turn a sleeping laptop into an always-on service. OpenAI explicitly requires the desktop app and computer to remain running for scheduled work that needs local projects. Choose an execution environment that matches when the task must run. Local scheduling requirements.

Finally, more open chats do not create more included capacity. ChatGPT Work and Codex share usage, and task complexity, context, model choice and tool use affect consumption. The useful limit is how much work your allowance and review capacity can support, not how many conversations fit in the sidebar. Usage rules.

Who Should Adopt the Desktop Workflow

A solo technical builder or funded founder should try it now when independent tasks regularly wait behind one active coding session. Delegate bounded work, keep the results separate and review each before combining them. If every change depends on the previous change, a sequential CLI or IDE session may be easier to reason about.

A senior operator should adopt it for repeatable repository work once the task has a clear input, expected output and review step. A scheduled report is a good first candidate. A vague instruction to keep the business system healthy is not yet a usable task definition.

A CTO should pilot the workflow with one repository and a named reviewer before expanding it. The pilot should answer whether the team can prepare worktrees consistently, understand the generated changes and verify the combined result. Counting started chats will tell you little about accepted work.

Stay with the CLI or IDE extension if it already fits your daily loop and you have little parallel work to supervise. Changing interfaces is separate from changing coding agents; the latter decision belongs in Codex vs Claude Code.

Your Monday move: open one familiar repository, give two independent tasks separate worktrees, and take each through a reviewed commit. Add a scheduled task only after its prompt has produced an output you know how to evaluate.

Questions About the Codex App

What is the Codex app for?

It gives you a desktop workspace for supervising coding chats, using separate worktrees, reviewing diffs and performing Git operations. It is most useful when several independent tasks need attention.

Is Codex better than ChatGPT?

Choose Codex for repository work with codebase context and developer tools. The current desktop app lets you select Codex from the ChatGPT dropdown, so this is partly a workflow choice within the same app. Quickstart.

Is Codex free for free users?

OpenAI currently lists limited desktop Codex access on ChatGPT Free and Go, subject to rollout. That does not imply the same model or feature access as the other plans. Current access rules.

Is there no Codex app anymore?

The old Codex app documentation now directs you to the ChatGPT desktop app. Codex remains a documented selection inside it. Follow the current setup instructions when the app name differs from an older guide. App documentation.

Why is Codex removed?

The current documentation does not describe Codex as removed. It tells developers to select Codex for software work and continues to document the CLI and IDE extension. A changed desktop name is not evidence that the coding workflow disappeared. Quickstart.

How do I get the Codex app?

Use OpenAI's desktop download for your supported operating system, sign in and select Codex. Linux users should follow the preview's distribution-specific instructions. Official setup.

Can I get Codex on my phone?

OpenAI documents Codex in the ChatGPT mobile app and continuing cloud tasks on mobile. For connected-computer worktrees, the repository and execution stay on that computer; the phone controls the work. Mobile setup, worktree behavior.

Is there a separate app for Codex?

The current desktop installation path is the ChatGPT desktop app, with Codex selected inside it. The terminal and IDE remain separate ways to use Codex. Official installation path.

Why won't the Codex app open?

The cause depends on your operating system, installed build and exact error. Check the official platform requirements and troubleshooting page first. A launch failure, a sign-in problem and a repository setup failure need different diagnoses. Official troubleshooting.

For practical guides to using AI in development and operations, join the newsletter.