Codex Everywhere: IDE Extension, Desktop App & Web

The CLI is not the only place Codex lives. The exact same agent — same account, same models, same ~/.codex/config.toml — runs in your editor, in a native desktop app, and in the cloud. That is the real unlock: you do not pick a product, you pick a surface for the task in front of you, and the agent follows you across all of them carrying the same context.

A two-line typo fix wants the editor, where the diff lands inline next to your cursor. A four-hour refactor across thirty files wants the cloud, running on its own machine while you keep working. A "click through the signup flow and tell me what breaks" task wants the desktop app, which can drive a real browser and real Mac apps. Same Codex. Different room.

This guide maps the three surfaces — IDE extension, Desktop app, web/cloud — to the moments each one wins, with the exact labels, commands, and config so you can move between them without re-learning anything.

The one config to rule them all

Before the surfaces, the thing that ties them together. The Codex IDE extension does not reimplement the agent — [V] "The Codex IDE extension uses the Codex CLI." Behavior like the default model, approvals, and sandbox lives in the shared ~/.codex/config.toml file [V], not in editor settings. Set your default model and approval policy once in that TOML and the editor, the codex CLI, and the desktop app all read it. Editor-only preferences (font size, CodeLens toggles) stay in your IDE settings; everything that governs the agent is shared.

Surface 1 — the IDE extension

The extension is published on the VS Code Marketplace by OpenAI as openai.chatgpt [V] — that exact publisher.extension id, which matters because lookalikes exist. It is not VS Code–only: it runs in VS Code, VS Code Insiders, Cursor, Windsurf, and JetBrains IDEs (Rider, IntelliJ, PyCharm, WebStorm) [V], on macOS, Windows, and Linux.

What you get over the bare CLI is editor context for free. [V] "Use open files, selections, and @file references to get more relevant results with shorter prompts." Type @ and reference a file by name — @example.tsx, @resources.ts — and Codex pulls it in without you pasting paths. Your current selection and open tabs become context automatically, so a prompt as short as "make this return a Result type" lands on the right code.

The three approval modes

This is the dial that decides how much rope Codex gets. You switch between Chat, Agent, and Agent (Full Access) [V] "depending on how much autonomy you want Codex to have."

The reasoning-effort dial

Next to the model switcher sits a reasoning-effort control — low, medium, or high [V] — to "trade off speed and depth based on the task." This is a real lever, not decoration: high thinks longer and spends more tokens before acting (worth it for a thorny concurrency bug); low answers fast (right for renaming a variable or writing a docstring). [P] A good habit is to default to medium and bump to high only when a task is genuinely hard — over-reasoning a trivial edit just burns tokens and time.

Delegate to the cloud without leaving the editor

The extension's quiet superpower: it is also a launchpad for cloud tasks. [V] "Kick off a cloud task from your editor, then monitor progress and apply the resulting diffs locally." You offload a long job to a cloud environment, keep coding, watch progress in a panel, and when it finishes you preview and apply the resulting diffs locally. You stay in one window; the heavy lifting happens on someone else's machine.

Surface 2 — the Desktop app

The Codex desktop app is a native application for macOS (Apple Silicon and Intel) and Windows [V]. You download and install it, sign in with your ChatGPT account or API key, and launch it like any app. (There is also a codex app entry point [P] from the CLI for opening it.) Where the editor extension is "Codex inside your code," the desktop app is "Codex that can also touch the rest of your machine."

Parallel threads, isolated by Git worktrees

The headline feature is true parallelism that does not corrupt your tree. You run multiple project threads side by side and switch between concurrent tasks [V], and each is kept clean by built-in Git worktree support — [V] "Keep parallel code changes isolated with built-in Git worktree support." A worktree is a second working directory checked out to its own branch from the same repo, so thread A refactoring auth/ and thread B writing tests in billing/ never stomp on each other's files. You get three agents working at once without three copies of the repo and without merge chaos.

Computer use, Appshots, and the in-app browser

The desktop app reaches past your codebase into the GUI:

• Computer use — Codex can operate macOS applications for GUI interactions, browser workflows, and native-app testing [V] directly from the desktop. This is how "test the actual signup flow" becomes a real task instead of a description.
• Appshots — [V] "Send the frontmost Mac app window to Codex with a screenshot and available text." One action hands Codex what you are looking at — the window image plus its readable text — so you can ask about a UI without describing it.
• In-app browser — an integrated browser lets you view rendered pages, add comments, or let Codex automate browser workflows locally [V]. The agent sees what renders, not just what the HTML says.

Rounding it out: an integrated terminal, review tools for diffs and Git operations, image generation/editing, automations for scheduled recurring tasks, plus skills and plugins [V]. The desktop app is the surface when the task is visual or cross-application — anything where Codex needs eyes and hands on more than text files.

Surface 3 — the web / cloud

Cloud tasks run Codex on its own machine, in the background, so the work outlives your laptop lid. You can start one from three places [V]:

1. The web — go to chatgpt.com/codex after connecting your GitHub account, pick a repo, and describe the task.
2. The IDE extension — [V] "Kick off a cloud task from your editor, then monitor progress and apply the resulting diffs locally."
3. GitHub — [V] "Tag @codex on issues and pull requests to spin up tasks and propose changes directly from GitHub."

The cloud environment is configurable: you "Choose the repo, setup steps, and tools Codex should use" [V], and you "Decide whether Codex can reach the public internet from cloud environments, and when to enable it" [V] — network access is off by default and you opt in deliberately. When a task finishes, you review its diffs and either apply them locally or have Codex open a pull request straight from GitHub [V].

The mental model: cloud is for jobs that are long, parallelizable, or detached from your active editing — a big migration, a fleet of small fixes, anything you would rather kick off and check on later than babysit.

The whole picture

Stop thinking "which Codex." There is one Codex, and it shows up wherever you are working. The IDE extension (openai.chatgpt [V]) puts it inline with @file context and three honest autonomy levels. The desktop app gives it eyes and hands — computer use, an in-app browser, Appshots, and worktree-isolated parallel threads. The cloud lets it run detached and at scale, kicked off from the web, your editor, or a @codex GitHub tag.

Pick the surface that matches the shape of the moment — inline edit, visual test, or long detached job — and let the shared ~/.codex/config.toml keep the agent itself consistent across all three. That is Codex everywhere, working as one tool with three doors.