You search for a guide to "Codex" and find ten that do not describe the same thing: one is about a model you call through an API, another about an app, another about a command you run in the terminal. Before you install anything you need a map, and the map has to be dated, because this product changes faster than the guides that describe it. The answer, read on November 13, 2026 in the official documentation, is this: Codex is an OpenAI coding agent that reads your code, edits it, runs commands and hands you a result to review. You reach it from several entry points (the ChatGPT apps, the terminal, the editor, the cloud) and you sign in with a ChatGPT account or with an API key. The choice of access matters more than it seems, because with an API key the pricing page excludes the cloud features. The CLI is open source under the Apache-2.0 license; the IDE extension and the cloud are not.
Method and limits. I am not affiliated with OpenAI. I did not install or run the Codex CLI and I did not call any model: what happens inside the tool I report from the documentation, I do not vouch for it from experience. The official pages listed at the end were read on 2026-11-13. The scripts in this article are mine, they do not touch Codex, and each one was run twice with the same output (Python 3.14 on Linux).
One name, four meanings: why the guides contradict each other
The Deprecations page of the OpenAI API lists, with a shutdown date of March 23, 2023 (notice date March 20), the models code-davinci-002 (the row labeled "Codex models"), code-davinci-001, code-cushman-002 and code-cushman-001. Anyone who reads a tutorial today that asks them to call those names is reading something that no longer works. The openai/codex repository on GitHub shows as created on April 13, 2025 (the created_at field of the GitHub API): it is the home of the agent this series is about. I have no primary source for the announcement dates of the individual products, so I do not write them.
- An API model. The
code-davinci-*andcode-cushman-*names, retired in 2023. If a guide talks abouttemperatureandmax_tokens, it describes this. - A terminal agent. The
codexCLI, installable with a shell one-liner, with npm or with Homebrew, which works in your project folder. - A family of surfaces. The same agent reachable from the desktop and mobile apps, the web, the IDE extension and the cloud, plus the SDK and the non-interactive mode for scripts.
- A suffix in a model name. Identifiers such as
gpt-5.3-codex, which the Models page marks as already deprecated in Codex with ChatGPT sign-in.
The criterion for finding your way is the date of the guide and the command it shows. A tutorial with sampling parameters and an API key in a Python script is about the first meaning; one with npm install -g @openai/codex is about the second; one with screenshots of the app is about the third. If you come across a model name with codex in it, do not assume it still exists: check it on the Models page. A practical sign of how much the ground shifts: the address developers.openai.com/codex today redirects to learn.chatgpt.com/docs (I verified it by following the redirect with curl -L), because the Codex documentation lives inside the ChatGPT one. If your bookmarks point to the old address, update them.
Where the work runs: the surfaces
It helps to think in terms of where the work runs, not of the product name. The table summarizes what the official pages say about each entry point; the right-hand column is my own summary, and where the source is silent I say so.
| Surface | Where it runs | When it makes sense (my summary) |
|---|---|---|
| CLI | On your computer, in the repository where you start it | You work from the terminal and want to see the commands as they go by |
| IDE extension | On your computer, inside the editor, with open files and selections as context | You want to stay in the editor; for long jobs the page points to Codex on the web |
| ChatGPT desktop app | Each chat is set to Local or Worktree (both on your computer) or Cloud | You want to decide case by case and isolate changes in a Git worktree |
| Mobile | In the cloud or on a connected computer: from the phone you start, steer and approve | You follow a job that is already running without going back to your desk |
| Cloud | In a remote environment, with its own working files for each task | Long or parallel tasks that you do not want to keep on the laptop |
SDK, codex exec, GitHub Action | Wherever you launch them: scripts, CI, GitHub events | Repeatable automation (part 6 of the series) |
The basic trade-off is between control and continuity. Local means you see every command and the files stay on your machine, but the work stops when you turn the computer off. Cloud means each task has its own workspace and can go on while the computer sleeps, as the cloud page says, but in exchange the task only sees what the remote environment contains: the environments page warns that local files, running processes, browser sign-ins and VPN access are not transferred automatically. An example: if the test you need to make pass requires a database reachable only through the company VPN, a cloud task will fail for reasons that have nothing to do with the code.
What is open and what is not
The Open Source page of Codex has a table of components, which I reproduce in full for the parts that matter for deciding.
| Component | Status according to the page |
|---|---|
| CLI | Open, in openai/codex ("The primary home for Codex open-source development") |
| SDK and App Server | The sources live in the same repository |
| Skills and plugins | Dedicated repositories: openai/skills and openai/plugins |
| Universal cloud environment | The base used by the cloud is open: openai/codex-universal |
| IDE extension | Not open source |
| Codex cloud | Not open source |
What you take from it: you can read the code of the agent that runs on your computer, report problems and reproduce them, but you cannot propose fixes with a pull request, because the page specifies that the repository accepts contributions in the form of issues and does not accept external code. The piece that runs in the cloud, on the other hand, cannot be inspected. I read the license of the CLI from the GitHub API, which reports Apache-2.0 for openai/codex.
ChatGPT account or API key: the choice you make first
The Authentication page says that the desktop app, the CLI and the IDE extension accept both methods for local work, while Codex cloud requires signing in with ChatGPT. It also says something that is easy to miss: the sign-in method also decides which administrative controls and which data rules apply. The practical consequences are two.
- ChatGPT sign-in. Usage follows the permissions of your workspace, the roles (RBAC) and, for Enterprise, the retention and data residency settings. Consumption falls on the quotas of the plan, in five-hour windows plus possible weekly limits, and you also get the cloud features.
- API key. Usage follows the data retention and sharing settings of your API organization, and you pay at API prices. The API key card on the pricing page lists CLI, SDK and IDE extension, and declares "No cloud-based features"; model availability follows the models your key can use.
The deciding factor is not only cost but perimeter. Anyone working on code subject to contractual constraints must know which of the two data rules they are working under, and that choice is made at sign-in, not afterwards. Whoever automates in CI has one more reason to use the API key: the card describes it as suited to automation in shared environments.
To make explicit what the documentation states and what it leaves unsaid, I wrote a small three-valued table. Every cell comes from the Pricing and Authentication pages; where the page does not name the surface the value is "nd" (not declared) and it is never turned into a "yes" for convenience. The verdict function answers the question "with this access, do I have what I need?" by telling apart three cases: excluded, to verify, covered. The second function in the same file, version, is used to compare your CLI version with the minimum the Models page requires for GPT-6.1 Terra (0.159.0): a pre-release such as 0.170.0-alpha.4 is ordered after 0.159.0, because the numeric part is compared first.
"""Three-valued table: the Codex documentation says yes, no, or stays silent.
Every cell is copied from an official page (see SOURCE); where the page
does not name the surface the value is ND (not declared), never a guessed yes.
"""
YES, NO, ND = "yes", "no", "nd"
SURFACES = ("desktop", "web", "cli", "ide", "cloud", "sdk")
# SOURCE: Pricing page (plan cards) and Authentication page, consulted on 2026-11-13.
ACCESS = {
"Free/Go": dict(desktop=YES, web=ND, cli=ND, ide=ND, cloud=ND, sdk=ND),
"Plus/Pro": dict(desktop=ND, web=YES, cli=YES, ide=YES, cloud=YES, sdk=ND),
"Business": dict(desktop=YES, web=ND, cli=ND, ide=ND, cloud=YES, sdk=ND),
"API key": dict(desktop=ND, web=ND, cli=YES, ide=YES, cloud=NO, sdk=YES),
}
def verdict(access, needs):
cells = ACCESS[access]
missing = [s for s in needs if cells[s] == NO]
uncertain = [s for s in needs if cells[s] == ND]
if missing:
return "EXCLUDED (the page says no): " + ", ".join(missing)
if uncertain:
return "TO VERIFY (the page is silent): " + ", ".join(uncertain)
return "COVERED by the page"
def version(text):
"""'0.170.0-alpha.4' -> ((0, 170, 0), 0): a pre-release precedes the stable one."""
base, _, pre = text.partition("-")
return tuple(int(p) for p in base.split(".")), (0 if pre else 1)
# SOURCE: Models page: GPT-6.1 Terra requires Codex CLI 0.159.0 or later.
TERRA_MINIMUM = version("0.159.0")
if __name__ == "__main__":
for needs in (("cli", "cloud"), ("cli", "sdk"), ("cli", "ide")):
print("needs:", "+".join(needs))
for name in ACCESS:
print(f" {name:<11} {verdict(name, needs)}")
for installed in ("0.158.9", "0.159.0", "0.167.2", "0.170.0-alpha.4"):
ok = version(installed) >= TERRA_MINIMUM
print(f"CLI {installed:<16} Terra: {'ok' if ok else 'too old'}")
# Command: python3 -I scegli_accesso.py
# Output:
# needs: cli+cloud
# Free/Go TO VERIFY (the page is silent): cli, cloud
# Plus/Pro COVERED by the page
# Business TO VERIFY (the page is silent): cli
# API key EXCLUDED (the page says no): cloud
# needs: cli+sdk
# Free/Go TO VERIFY (the page is silent): cli, sdk
# Plus/Pro TO VERIFY (the page is silent): sdk
# Business TO VERIFY (the page is silent): cli, sdk
# API key COVERED by the page
# needs: cli+ide
# Free/Go TO VERIFY (the page is silent): cli, ide
# Plus/Pro COVERED by the page
# Business TO VERIFY (the page is silent): cli, ide
# API key COVERED by the page
# CLI 0.158.9 Terra: too old
# CLI 0.159.0 Terra: ok
# CLI 0.167.2 Terra: ok
# CLI 0.170.0-alpha.4 Terra: ok
Read the output like this. For CLI plus cloud, only Plus and Pro are "covered" by the pages; the API key is excluded because the card says no; Free, Go and Business come out as "to verify" because the card does not name the CLI. For CLI plus SDK the opposite holds: the API key is the only covered combination, because the card for the ChatGPT plans does not mention the SDK. It is a limit of this script, declared in the comment: it covers only what two pages say, and pages change. Before you buy, reopen the pricing page: the script tells you where to look, it does not replace reading.
Plans and prices, as listed on November 13, 2026
Source: the Pricing page. Prices are in US dollars, as written by the page; I do not report amounts in euros or taxes, which the page does not detail.
| Plan | Declared price | What the page lists |
|---|---|---|
| Free | $0 a month | Quick tasks; GPT-6 Luna at Standard speed in the desktop app, "subject to rollout" |
| Go | $8 a month | Lightweight tasks; same model as Free |
| Plus | $20 a month | Codex on the web, in the CLI, in the IDE extension and on iOS; cloud integrations such as automatic code review and Slack; GPT-6.1 Sol and GPT-6 Luna; ChatGPT credits |
| Pro | From $100 a month | Tiers at $100, $200 or $500; Ultrafast mode is on the $500 tier |
| Business | $20 per user a month (at least 2 users, billed annually); $25 when billed monthly | Dedicated workspace, SAML SSO, MFA, credits; the page states no training on business data by default |
| Enterprise and Edu | Contact sales | SCIM, EKM, role-based access control, Compliance API, data retention and residency controls |
| API key | Pay as you go, per the API price list | CLI, SDK and IDE extension; no cloud features |
Two readings not to get wrong. The first: limits are not expressed in dollars but in local messages every five hours. For Plus the page gives estimates, and specifies that they are not fixed limits: for GPT-6.1 Sol from 15 to 160 messages, for GPT-6 Luna from 350 to 3,000, with possible weekly limits and with cloud tasks that may consume more. The width of those ranges is the data: a large task with a lot of context consumes far more than a small function, and the length of the prompt alone does not predict it. For Pro the page writes that at the moment there is no five-hour limit. The second: Fast mode consumes 2.5 times the included quota compared with Standard on the same model, according to the table on the page, and Ultrafast modes, for the two models the table lists, 8 times; if you notice the quota running out early, check the speed and the model you chose first, then the plan.
If you reach the limit in the middle of a turn, the page says the agent may continue that turn, within fair use limits; whoever has Plus or Pro can buy credits. The advice I draw from it, which is mine and not the documentation's, is to watch the usage dashboard for a couple of weeks before deciding whether to move up a plan: the page itself suggests checking it every week or two.
Which version you are looking at
The CLI changes at an almost daily pace, and the right way to say so is to measure it. The script that follows reads the public list of openai/codex releases (GitHub API, read-only, no key) and separates the stable ones from the pre-releases. The output changes with every release: it is today's measurement, and anyone can redo it with the same script. The field that matters is prerelease, which the API exposes for each item; the filter on the first thirty entries tells you how many are truly stable. This listing is reproduced exactly as in the Italian edition, since it reads from the network and its output changes over time: the labels printed by the script are in Italian (ultima stabile is the latest stable release, ultima prerelease the latest pre-release, release lette the releases read, di cui stabili how many of them are stable).
"""Quale versione della CLI di Codex e' l'ultima stabile, e quale e' solo una pre-release?
Legge l'elenco pubblico delle release del repository (API di GitHub, sola lettura,
nessuna chiave) e stampa tag e data. L'uscita cambia a ogni rilascio: e' la misura di oggi.
"""
import json, urllib.request
URL = "https://api.github.com/repos/openai/codex/releases?per_page=30"
richiesta = urllib.request.Request(URL, headers={"User-Agent": "controllo-versione"})
with urllib.request.urlopen(richiesta, timeout=30) as risposta:
release = json.load(risposta)
stabili = [r for r in release if not r["prerelease"]]
prerelease = [r for r in release if r["prerelease"]]
print("ultima stabile :", stabili[0]["tag_name"], stabili[0]["published_at"][:10])
print("ultima prerelease:", prerelease[0]["tag_name"], prerelease[0]["published_at"][:10])
print("release lette :", len(release), "- di cui stabili:", len(stabili))
# Comando: python3 -I ultima_stabile.py
# Output:
# ultima stabile : rust-v0.168.0 2026-11-13
# ultima prerelease: rust-v0.170.0-alpha.4 2026-11-12
# release lette : 30 - di cui stabili: 4
You see it in the output: among the last thirty releases the stable ones are four, the rest are alpha versions. The tags have the prefix rust-v. For you it means that "the latest version" is ambiguous, and that two colleagues may end up with different commands if one has installed a pre-release. Note the version you use, write it in the team's internal documentation and, before copying an option from a guide, check it with codex --help and with the commands reference page.
Models rotate too, and the Models page shows it with dates. GPT-5.5 was retired from Codex for those who sign in with ChatGPT on October 14, 2026 (sessions with an API key are not affected); gpt-5.4 and gpt-5.4-mini on August 31, 2026; GPT-5.3-Codex-Spark on September 14, 2026. If a script or a configuration file selects one of these names, it needs updating. An inconsistency that I point out without resolving: the Deprecations page indicates names of the 5.6 series as replacements (for example gpt-5.6-sol), while the Codex pages use gpt-6.1-sol; for Codex, the Models page prevails.
When Codex is not the right choice
- The code must not leave your machine. Even with the CLI running locally, the reasoning work goes through a model, and the sandbox protects your filesystem, not the confidentiality of the prompts. Read the data rules of the sign-in method you use, and for code with contractual constraints start from the Business or Enterprise plan.
- Your team already uses another agent. The cost of switching (written rules, habits, review procedures) often exceeds the difference between tools, and this is my own assessment, not a data point.
- The task is not verifiable. An agent pays off where you can say how the result is checked: a test that passes, a command that exits with zero. For design decisions still to be made, a conversation of your own comes first.
The common thread is that Codex is useful in proportion to how well you can verify what it produces. Where verification is missing, or where the data cannot leave, the problem lies upstream of the tool and no setting solves it.
Frequently asked questions
Is Codex still an OpenAI model?
No, not in the sense it once was. The code-davinci-* and code-cushman-* models were retired on March 23, 2023 according to the Deprecations page. Today Codex means a coding agent with several surfaces, which uses the models listed on the Models page; the suffix codex still appears in the names of some models.
Can I use Codex without a ChatGPT subscription?
Yes, in two ways that the pricing page lists. The Free plan includes the desktop app with GPT-6 Luna, subject to rollout. With an API key you use the CLI, SDK and IDE extension and pay at API prices, but without cloud features. For the CLI with the free plans the page says nothing, so check before counting on it.
Is the CLI software free?
The code is open under the Apache-2.0 license and you install it without paying for the software. Using it, however, consumes the quota of your plan or API credits, and that is what really costs.
What you can do now
You can tell the four meanings of the name apart, choose between a local and a cloud surface based on where the files must stay, decide between a ChatGPT account and an API key knowing the difference in data rules, and check which version of the CLI you are using. The rest of the series is designed in this order, but each part can be read on its own.
- This product map.
- Installation and first task, with a perimeter check on the changes.
- Sandbox and approvals, with an executable table of the two knobs.
- AGENTS.md and config.toml, with a shape validator.
- Models, reasoning and costs.
- Codex exec and the SDK for automation.
- Cloud, subagents, skills and MCP.
- The comparison with Claude Code, Copilot and Cursor.
The order is that of a progression: first access and perimeter, then the stable rules, then costs and only at the end automation and delegation, which amplify the configuration mistakes made earlier. If you come from another tool, I have also written about the workflow with Claude Code, the guide to Cursor and GitHub Copilot.
What I did not verify
I did not install or launch the CLI for this series, so I did not measure speed, quality of the code produced or real quota consumption: where you find a selection criterion, it is a criterion to apply to your own code, not a result of mine. I did not verify availability by country, nor whether the dollar prices on this page match those you will see at the time of purchase, and I did not open the Business and Enterprise pages beyond the pricing card. The announcement dates of the products are left out because I have no primary source.
Sources
- Pricing - plans, dollar prices, five-hour limits, Fast and Ultrafast modes, API key card; consulted on 2026-11-13
- Authentication - the two sign-in methods, the cloud only with ChatGPT, data rules by method; consulted on 2026-11-13
- Models - retirements of GPT-5.5, GPT-5.4 and Spark; GPT-6.1 Terra requires CLI 0.159.0 or later; consulted on 2026-11-13
- Open Source - which components are open, what the repository accepts; consulted on 2026-11-13
- Codex environments - Local, Worktree and Cloud; what is not transferred to the cloud; consulted on 2026-11-13
- Codex Cloud - tasks with their own workspace, running while the computer is at rest; consulted on 2026-11-13
- Deprecations (OpenAI API) - the shutdown of the Codex models on March 23, 2023; consulted on 2026-11-13
- Releases of openai/codex - tags and dates of the versions; the source is the
ultima_stabile.pycommand reported above, run on 2026-11-13
The scripts were run with Python 3.14 on Linux, twice, with the same output; the Codex CLI was not installed or run. Prices and limits change: the date of each consultation is the one indicated.
Commenti
Caricamento commenti...
Sign in to comment