OpenAI Codex: What It Is, How to Install It, and Regional Access Conditions in 2026

The word “Codex” in search results means three different things, and people who type it in for the first time usually don’t understand what they’ve found. There was a Codex model—it was shut down in 2023; today, the name belongs to an agent program, and another dozen products with the same name are in the mix.

I’m covering just one Codex: OpenAI’s coding agent. What it does, where it runs, how much it costs, how to install it in five minutes, and what OpenAI says about countries. It’s all based on official documentation, with links for every figure at the end.

Additional materials on setting up tools are in the Ailoot documentation.

What is OpenAI Codex?#

Compare it with a regular chat. In a chat, you copy a piece of code, paste it in, get an answer, then copy it back. An agent works differently: you describe a task in plain language, and it opens the relevant files in your project folder, makes changes, runs checks, and shows you the result.

OpenAI describes it in one line in its repository:

Locally means the program is downloaded to your machine, where it can see your files and run commands in your folder. Only the request to the model goes to the cloud.

The open-source code is on GitHub under the Apache-2.0 license. As of August 1, 2026, the repository has 103,000 stars, and the latest version, 0.146.0, was released on July 29. Updates come out almost every day, so your version will most likely already be different.

How is Codex in 2026 different from the old Codex that was discontinued?#

People confuse them all the time because both products are official and both are from OpenAI. Their dates set them apart.

The first was a set of models: code-davinci-001, code-davinci-002, code-cushman-001, code-cushman-002. They did one thing—complete code for you—and powered the first GitHub Copilot. In OpenAI’s list of discontinued models, all four appear on one line: announced on March 20, 2023, discontinued on March 23, with gpt-4o as the recommended replacement.

The second is a program installed on your computer. The @openai/codex package appeared in the npm registry on April 16, 2025. The model inside it is replaced with a newer one over time, while the program itself stays the same.

Any instructions about Codex from before April 2025 describe a discontinued product. If you find material that calls Codex a model and suggests calling it through code-davinci-002, close it.

Where does Codex work: terminal, editor, browser, or app?#

You don’t have to choose between them. The sign-in is the same, and so is the account. The only difference is where it’s more convenient for you to work.

The extension works differently for Xcode and JetBrains than it does for the other editors:

Cloud works differently from the other four. The task goes to an OpenAI container, where a copy of the repository is checked out from GitHub. The agent works without your computer, and you later review the result and decide whether to bring the changes into your own copy. Setup takes three steps: connect GitHub, create an environment with the required dependencies, and assign a task.

If you sign in with an API key, the terminal, editor, and app work. Cloud is unavailable with a key, as are the features tied to it, such as automatic code review and launching tasks from Slack. You need to sign in with a ChatGPT account for those.

Which model runs inside Codex?#

OpenAI sums it up in one line:

There’s a second control next to the model: reasoning effort. It has four settings: Low (called Light in the app and editor), Medium, High, and Extra High. OpenAI recommends using the lowest level that gets the result you need and raising it when a task requires planning.

There are two more modes above that. Max gives the model more time on a task. Ultra splits the work into parts and assigns them to subagents in parallel. The documentation says directly that most tasks need neither.

There’s also a separate entry, gpt-5.3-codex-spark—a research version for quick iterations, available only on the Pro plan.

Choosing the model and reasoning effort is already context engineering: you decide how much the agent thinks and what it brings to the task.

How much does Codex cost, and what’s included in the plans?#

I checked prices against the official pricing page on August 1, 2026.

Business costs $25 per seat with monthly billing instead of $20.

Now, about limits. OpenAI doesn’t give one fixed number:

Instead of one number, OpenAI publishes a range: how many messages you get over five hours when working on your own machine. The figures are the same for Plus and Business:

On the $100 Pro plan, all figures are multiplied by five; on the $200 Pro plan, by twenty. OpenAI also mentions weekly limits in addition to the five-hour window, but publishes no specific figures for them.

The tenfold range within a single model has a simple explanation. One message can use either one percent or ten percent of your daily allowance, because the amount of work done is what counts, while the number of requests has little effect. I explained how tokens get used in practice in detail using Claude as an example in Claude Pro and Max limits—the mechanics are exactly the same.

When you run out, there are three options: buy extra credits without changing your plan, switch to a lighter model, or start a session with an API key and pay for tokens as you use them.

What regional restrictions apply to Codex?#

OpenAI publishes its official list of supported countries and territories publicly. Belarus is not on the list. Kazakhstan, Armenia, Georgia, Turkey, Serbia, and Ukraine are on it.

The wording on that same page:

Installing and running the program is one thing; access to the model is another. The country check kicks in at sign-in: both signing in through ChatGPT and signing in with an API key lead to an OpenAI account.

A country-related rejection looks like this:

{
  "error": {
    "code": "unsupported_country_region_territory",
    "message": "Country, region, or territory not supported",
    "type": "request_forbidden"
  }
}

The unsupported_country_region_territory code and 403 status indicate a country-related rejection. If you see this, it means you didn’t break anything during installation, and Node has nothing to do with it.

There’s a second barrier that isn’t described in the documentation at all but comes up more often in real life. It’s phone number verification. The report “Phone number verification doesn’t work” has 206 comments; a second report, about an old number that’s no longer accessible and can’t be replaced, has been open since June 2026 and has 71 comments. The same story keeps coming up: ChatGPT works in the browser on the same account, but Codex asks for phone verification, and there’s no way around it. OpenAI doesn’t publish a list of countries whose phone numbers it accepts, so there’s no way to check yours in advance.

I’m not covering workarounds; this article is about how the tool works.

Anthropic also publishes its list of supported countries, and it works the same way. Materials that present one tool as “allowed” and another as “blocked” simply mislead readers—they’re formally in the same position. Both lists change, so check the current versions.

How to install Codex: step by step#

The technical part starts here, for those who already have an active OpenAI account.

1. Install the program

   Choose the method for your system. Use the same method later to update the program to the latest version.

2. Open the project folder

   The agent works in the folder from which you launched it. Go there before running the first command.

3. Sign in to your account

   The first time you run codex, it will offer to sign you in. A browser will open, and after you sign in, control will return to the terminal.

4. Give it your first task

   Describe what you need in plain language. Start with something harmless, like asking it to describe the project.

Installation command for macOS and Linux:

curl -fsSL https://chatgpt.com/codex/install.sh | sh

On Windows, use the same installer through PowerShell:

powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"

If you already have Node, you can install it through npm:

npm install -g @openai/codex

Homebrew works on macOS. Make sure to use --cask; without it, you’ll install the wrong thing:

brew install --cask codex

On Linux and WSL2, the sandbox is built on bubblewrap, which you need to install ahead of time:

sudo apt install bubblewrap

On Fedora and related systems, use sudo dnf install bubblewrap. Also, WSL version 1 was supported through version 0.114; starting with 0.115, the sandbox moved to bubblewrap and WSL1 no longer worked. On Windows, though, everything also works without WSL, using its own built-in sandbox.

What should you do at first launch?#

To start, go to the project folder and type codex; a session will open. Then describe the task in plain language, without any special syntax.

Five commands for your first few minutes:

1. /status - the model, approval policy, and which folders the agent considers its workspace.
2. /permissions - the current access mode and how to switch between modes.
3. /model - change the model and reasoning effort.
4. /init - creates an AGENTS.md file describing the project; more on that in the next section.
5. /review - a separate review of your changes, without editing files.

Besides plain codex, three useful terminal commands are:

codex resume                    # return to the previous conversation in this folder
codex exec "fix the tests"      # one-off run without a dialogue, for scripts
codex --image screenshot.png    # attach an image to the task

On both the terminal and extension documentation pages, OpenAI repeats the same advice: commit before and after a task. The agent edits files on its own, and you’ll want to be able to revert with one command as soon as the first day.

How do you explain your project to Codex with AGENTS.md?#

The order is strict, and the documentation states it in the very first line of the section:

First, Codex reads the global file ~/.codex/AGENTS.md, where you put habits that apply to all your projects. Then it reads files in the project itself: one file per folder, from the repository root down to your current folder. They’re combined from top to bottom, and a closer file overrides a more distant one. That means a rule in services/payments takes precedence over a general rule from the root.

A simple file looks like this:

# AGENTS.md

## How to work with this project

- Run tests with `npm test`; don't run them one file at a time.
- Install packages with pnpm.
- Ask me before adding a new production dependency.
- Do not touch the `legacy/` folder at all.

The limit is 32 kilobytes for the combined files. After that, files simply stop being added, without notice. An oversized AGENTS.md also burns through the limit on every run because the entire file goes into context.

If you know CLAUDE.md, the mechanics will look familiar: it’s the same technique under a different name. The project rules file works as the foundation of a Second Brain: the agent learns about your work before you’ve had a chance to explain anything. I covered how to use both files in one project in AGENTS.md and CLAUDE.md together.

What does Codex do on its own, and what requires approval?#

These two settings are often confused, so OpenAI spells out the difference in one line:

Switching review to automatic leaves the working-folder boundaries as they were. Automation just removes the clicks; it doesn’t change the agent’s permissions.

The app and editor have three access modes. Ask for approval is always available and is the recommended starting point. Approve for me and Full access must first be enabled in settings.

The terminal has its own logic: the program checks the folder and suggests a suitable set of permissions.

Network access is off by default in local mode. The agent runs commands it came up with itself, and no one would let that reach the internet by default.

Even inside the working folder, the agent can only read certain locations in every mode: .git, .agents, and .codex. Use /status to see which folders the agent currently considers its workspace.

There’s also full access mode—the --dangerously-bypass-approvals-and-sandbox flag. The documentation marks it as higher risk and labels it “not recommended.” The flag’s name says it all; I have nothing to add.

Codex or Claude Code: which should you choose?#

The difference between the tools is smaller than you might conclude from online arguments. Both read your project and edit files on their own, and both ask before going beyond the folder.

At the start, it’s easiest to look at what you already pay for. If you have a ChatGPT subscription, Codex is already included; you don’t need to pay separately. I made a detailed comparison with measurements in a separate piece about Codex vs. Claude Code, and if you want to move your working settings from one to the other, there’s a migration guide.

What most often breaks on first launch?#

This list is based on reports in the project repository. There’s no guesswork here; every item comes from someone who ran into it.

1. The wrong package was installed. npm install -g codex without a prefix installs a static site generator from 2011. The correct package is @openai/codex.
2. bubblewrap isn’t installed. Without it on Linux and WSL2, the sandbox doesn’t start. Codex switches to its built-in fallback and complains at startup. Install it with one command.
3. Access denied by country. The unsupported_country_region_territory code and 403 status appear at sign-in. Installation has nothing to do with it.
4. Phone verification is required. This doesn’t happen to everyone and isn’t described in the documentation. There’s no official way to replace an inaccessible number; the report about it has been open since June 2026.
5. You run out of usage limits sooner than expected. The report “Tokens burn up very quickly” is the most discussed in the entire repository, with 627 comments. Switching to a lighter model and lowering reasoning effort can help.

The interface language doesn’t affect the agent’s work: the task language doesn’t have to match the interface language.

What to do next#

The first hour with an agent always goes toward the same thing: figuring out how far it can go on its own. You can only learn that with your own project; an example in the documentation won’t tell you.

Here’s the order I recommend to start:

1. Install the program and sign in to an active OpenAI account.
2. Open a real project folder and run codex.
3. Check /status and /permissions, explicitly choose read-only access for an inspection-only task, and verify the active mode before asking how the project is organized.
4. Make a commit and give it its first editing task.
5. Write a three-line AGENTS.md and compare how the agent responds before and after.

Find additional materials on working with tools in the Ailoot documentation.