Codex Cloud Tasks, Explained
Published October 14, 2026 · by the AQ team
A Codex cloud task is a Codex coding task that runs on an OpenAI-managed virtual machine instead of your computer, so the work keeps going while your laptop is asleep. OpenAI relaunched the feature at DevDay on September 29, 2026 around a new primitive called a cloud environment: a reusable, published setup holding your repositories, dependencies, tools, and access settings, from which every new task gets its own isolated workspace. The previous architecture is now labeled Codex Cloud (Legacy) in OpenAI's docs, which say it will be deprecated; it still powers Code Review and the Linear and GitHub integrations as of October 2026. This guide covers what runs where, what persists, and how Codex Cloud compares with the Codex CLI on your own machine and with Claude Code cloud sessions.
What is Codex Cloud?
Codex Cloud is the hosted execution side of Codex. Per OpenAI's documentation as of October 2026, you start a task by choosing Work in, then Cloud, on the web or in the ChatGPT desktop app (on mobile, you open Codex directly), selecting a published environment, and describing the work. Codex edits files, runs commands, and checks its work inside an isolated workspace built from that environment; you review the changes and test results before committing or opening a pull request. Reopening the same task from the web, desktop, or phone continues it where it left off.
Availability is plan-gated: OpenAI lists Codex Cloud as available to eligible Plus accounts, all Pro tiers, Business, Enterprise, Healthcare, and Education, subject to rollout and workspace settings. Free and Go plans include Codex itself but not cloud tasks, and signing into Codex with an API key gives no cloud features at all.
Cloud environments: the setup is now a conversation
The September 2026 relaunch replaced hand-written setup scripts with a conversational flow. You create an environment by selecting GitHub repositories, then selecting Get started: Codex inspects the repositories, installs dependencies and tools, and tests the workflow, asking for anything it cannot infer. When the setup report looks right, you Publish, which captures the prepared filesystem so new tasks start with dependencies already installed. Codex records the tested setup as an Install script (commands that install dependencies and prepare assets) and a Start skill (instructions that start services and check they are ready).
The legacy model this replaces still applies to Code Review and the GitHub and Linear integrations: a container from the codex-universal base image, a hand-written setup script that ran with internet access, container state cached for up to 12 hours, and secrets removed before the agent phase. The new environments instead rely on the published filesystem plus a background repository refresh that preserves dependency caches.
What persists, and for how long
Three layers of state behave differently, per OpenAI's docs as of October 2026:
- The published environment persists until you edit and republish it; republishing affects new tasks only.
- A task's own workspace keeps its saved files, uncommitted changes, and installed tools across follow-ups. By default a task's saved VM state is recoverable for up to seven days after you last start a turn or resume the task.
- Anything uncommitted has a lifetime you do not control past that window. OpenAI's own warning is blunt: saved state does not replace source control, so have the task commit and push what you want to keep.
VM specs are fixed per plan: 2 vCPUs, 8 GiB of memory, and 8 GiB of disk on Plus; 4 vCPUs, 16 GiB, and 32 GiB on Pro, Business, Enterprise, and Edu, with larger configurations available for Enterprise by request.
Network access, secrets, and private services
Internet access is off until you turn on Allow Codex to access internet in the environment configuration, then pick one of three scopes: a Package managers preset (npm, PyPI, crates.io, Go, Maven, apt, GitHub, and similar hosts), Custom domains only, or All (unrestricted). Everything routes through OpenAI's proxy. Secrets come in two shapes: environment variables, passed directly to programs, and network secrets, where programs only ever see a placeholder and the proxy substitutes the real value for allowed HTTPS destinations, so the agent never holds the raw credential. A Personal vault lets a shared environment request credentials that each person supplies from their own account.
Reaching services inside a private network goes through a VPN connection; Tailscale is the only supported provider as of October 2026. Enterprise workspaces can also attach OIDC identities (by request) so a task obtains short-lived cloud credentials instead of long-lived keys. Two limitations are stated plainly in the docs: cloud environments do not yet support computer and browser use, and GitLab and self-hosted GitHub Enterprise Server are not supported.
Starting tasks from the terminal, GitHub, and Slack
The CLI has an experimental bridge to the cloud, using the same sign-in as the rest of the CLI; submission failures exit non-zero, so it scripts cleanly:
# Interactive picker for recent cloud chats
codex cloud
# Submit a task directly to a published environment
codex cloud exec --env ENV_ID "Fix the flaky test in auth.spec.ts"
# Best-of-N: run up to four independent attempts of the same task
codex cloud exec --env ENV_ID --attempts 3 "Refactor the logger"
# List recent cloud chats, machine-readable
codex cloud list --jsonBeyond the terminal, mentioning @codex in a GitHub pull request requests reviews or fixes through the legacy integration path, and Enterprise workspaces with Cloud delegation enabled can start tasks by asking @ChatGPT in Slack or Microsoft Teams.
Codex Cloud, the local CLI, and Claude Code cloud sessions
Three ways of running coding agent work are easy to conflate, as of October 2026:
| Option | Where it runs | What persists | Environment |
|---|---|---|---|
| Codex Cloud task | OpenAI-managed VM, one isolated workspace per task | Task state recoverable 7 days after the last turn; the published environment indefinitely | Published cloud environment: repos, dependencies, tools, network policy |
| Codex CLI on your machine | Your laptop or server, OS-enforced sandbox | As long as your disk; sessions stop when the machine sleeps | Your real checkout, local services, full toolchain |
| Claude Code cloud session | Anthropic-managed VM, one per session | Paused VM resumable until the environment expires, then a fresh clone | Fresh GitHub clone plus an optional cached setup script |
Against the local CLI, the trade is environment versus lifetime: a cloud task cannot see your local files, dev servers, or anything outside its allowed network, but it survives a closed lid, which the local agents dashboard does not (covered in Codex background agents and the agents dashboard). Against Claude Code cloud sessions, the structures rhyme (managed VM, GitHub-centric, work comes back as a branch or diff to review) and the differences are in setup and persistence: Codex publishes a reusable environment that many tasks share and keeps task state for seven days, while Claude Code clones fresh per session with a cached setup script and pauses the VM until it expires. Both share one usage allowance with their local counterparts; OpenAI's pricing page notes that cloud tasks may use more of your allowance than local messages.
A third shape, running the CLI yourself on a server you control, gets laptop independence with your own network and tools and no GitHub requirement; running Codex on a cloud VM walks it end to end.
Where AQ fits
AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. The honest comparison with Codex Cloud is about three defaults. First, infrastructure: a cloud task runs on an OpenAI-managed VM with a fixed spec, while AQ workspaces run on a VM your team connects from its own cloud or a dedicated always-on AQ-managed VM in its own isolated network, with no shared multi-tenant execution tier. Second, the agent: a cloud task runs Codex, while an AQ workspace runs whichever real CLI the job calls for (Claude Code, Codex, Cursor Agent, Kimi, Grok, or a plain shell) in a persistent tmux session streamed live to the browser, surviving a closed laptop and resuming from any device, with each engineer signed into their own OpenAI or Claude account, which AQ never marks up. Third, visibility: a Codex Cloud environment can be shared in an Enterprise workspace, but each task's working files stay the task owner's; in AQ, teammates open the same workspace and watch the same live session as it runs, and the owner can hand over typing by approving a control request in one click. Each workspace gets an isolated git worktree, agents commit and open PRs with per-user GitHub auth, and every workspace serves a live dev-server preview with shareable links that work without an account. The Free plan is a personal sandbox on a private machine AQ creates, with no time limit; the Team plan is $50 per user per month in early access (standard $200, billed monthly), rate locked for your first 12 months.
Plainly: for solo, well-scoped tasks on GitHub repositories, the relaunched Codex Cloud is a genuinely good part of a ChatGPT subscription, and the published-environment model fixes the old setup tax. A team workspace earns its place when you want the same always-on execution across every agent CLI you use, on infrastructure you control, with the live session itself as the thing your team shares.
Frequently asked questions
What is a Codex cloud task?
A coding task that runs on an OpenAI-managed virtual machine instead of your computer. You start one by choosing Work in, then Cloud, on the ChatGPT web or desktop app (or opening Codex on mobile), picking a published cloud environment, and describing the work. The task runs in its own isolated workspace, keeps working while your computer is asleep, and comes back as changes you review before committing or opening a pull request.
What is a Codex cloud environment?
The reusable setup cloud tasks start from: repositories, dependencies, tools, and access settings. Since the September 29, 2026 relaunch you build one conversationally: Codex inspects your GitHub repositories, installs and tests the setup, records it as an Install script and a Start skill, and you publish the prepared filesystem. Every new task starts from the published state with dependencies already installed.
Do Codex cloud tasks cost extra?
There is no separate compute charge for the VM. Local messages and cloud chats share your plan's usage allowance, and OpenAI's pricing page notes cloud tasks may use more of it than local messages, with weekly limits possible alongside the five-hour windows on Plus and standard Business. Cloud access requires at least an eligible Plus plan; Free and Go include Codex but not cloud tasks, and API-key sign-in has no cloud features.
What happens to a Codex cloud task when I close my laptop?
It keeps running: execution is on OpenAI's VM, not your machine. Between turns, the task's saved VM state (files, uncommitted changes, installed tools) stays recoverable for up to seven days after you last start a turn or resume it, and you can reopen the task from web, desktop, or mobile. Past that window unsaved state can be gone, so OpenAI's docs tell you to commit and push anything important.
Can Codex cloud tasks reach my private network or internal services?
Yes, with configuration. Internet access is off until enabled per environment, then scoped to a package-manager preset, custom domains, or unrestricted, all through OpenAI's proxy. Network secrets are substituted at the proxy so the agent only ever sees placeholders. Private services are reached over a VPN connection (Tailscale is the only supported provider as of October 2026), and Enterprise workspaces can request OIDC for short-lived cloud credentials.