Cloud, Data and AI: ChatGPT Codex in 2026: Features, Pricing & AWS, Azure, GCP, OCI Integration

Introduction

If you last evaluated ChatGPT Codex in 2025, almost everything you concluded is now out of date. The billing model changed in April 2026. The model lineup underneath it changed in July. And, most consequentially for anyone doing cloud architecture, Microsoft's exclusivity over OpenAI's API-accessible products ended in April 2026 — which is why Codex now runs on Amazon Bedrock and can be paid for with Oracle Universal Credits.

This guide covers what Codex does today, what it genuinely costs once you account for credits and overage, how to wire it into AWS, Azure, Google Cloud and Oracle Cloud Infrastructure, and how it compares to GitHub Copilot, Claude Code, Cursor, and the cloud vendors' own assistants. For the other side of this comparison, see our Claude Code review, or browse all our AI & ML coverage.

In this article

What Codex is in 2026

First, a disambiguation that still trips people up. The original Codex was a code-completion model released in 2021 and retired in 2023. The Codex discussed here is the agentic coding product launched in 2025: you give it a task, it works in a sandbox, runs commands, edits files, checks its own work, and reports back with a diff and logs.

It is not a single application. Codex is a harness that runs across several surfaces sharing one account, one set of project instructions, and one usage pool:

Codex CLI — the terminal agent, and the surface most teams standardise on for automation.
IDE extension — VS Code and compatible editors, with inline diff review.
Desktop app — local chats on macOS, Windows and Linux, plus a built-in browser and computer-use capabilities.
Codex cloud — background agents that run in OpenAI-hosted containers, delegate from GitHub issues, and open pull requests.
Codex SDK and codex exec — non-interactive mode for CI pipelines and scripted workflows.

The distinction between local and cloud surfaces matters more than it looks, because it determines which of the four clouds below you can actually use — and how much of Codex you give up when you do.

Key features that matter in production

Project instructions and subagents

Codex reads an AGENTS.md file from your repository root the way a new engineer reads a README: build commands, test commands, house conventions, what not to touch. Files can be nested per directory so a monorepo does not inject every team's conventions into every task. This is also the single biggest lever on cost — an oversized AGENTS.md is injected into every message you send.

Subagents let a lead session delegate isolated work — research a library, investigate one hypothesis about a bug — to separate instances that report back without polluting the main context.

MCP, skills and plugins

Codex speaks Model Context Protocol, so it can reach your Jira board, a Postgres instance, or an internal service through the same interface other agents use. On top of that sit skills (reusable instruction bundles) and plugins (packaged workflows plus MCP server configuration, distributable through a workspace's private catalogue with admin allow/block policies).

Cost warning worth internalising. Every connected MCP server adds context to every message. OpenAI's own guidance is to disable MCP servers you are not actively using. On credit-based billing this is not housekeeping, it is line-item spend.

Codex Security

Codex Security is an application-security agent that scans repositories, triages a findings backlog, proposes fixes, and writes vulnerability reports. It ships as a plugin, a CLI (including a GitLab CI integration), a TypeScript SDK, and a cloud service that reviews connected GitHub repositories. The cloud version is an Enterprise-tier feature; the plugin and CLI are more broadly available.

Sandboxing and permissions

Codex runs with configurable permission profiles — approve every command, approve writes only, or run fully sandboxed with restricted filesystem and network access. Organisations can pin these centrally via a requirements.toml managed configuration, with cloud-managed policy enforcement available on Business and above. If you are rolling Codex out beyond a pilot team, configure this before you configure anything else. Our DevOps coverage goes deeper on agent guardrails in CI.

Pricing: plans, credits, and what it really costs

There is no standalone Codex subscription. Access rides on a ChatGPT plan or an API key, and since April 2026 the metering underneath is token-based credits rather than a message count.

Published plans

Plan	Price	What you get
Free	$0/mo	Exploratory access for quick coding tasks.
Go	$8/mo	Lightweight coding. Cloud task delegation is not part of this tier.
Plus	$20/mo	The practical baseline. All surfaces, the GPT-5.6 family, cloud chats, GitHub PR review, Slack and Linear integrations, plus purchasable credits.
Pro 5×	$100/mo	Five times Plus rate limits, plus the low-latency GPT-5.3-Codex-Spark research preview.
Pro 20×	$200/mo	Twenty times Plus limits — four times the headroom of Pro 5× for double the price.
Business	$20/user/mo annual ($25 monthly, 2+ users)	SAML SSO, MFA, admin controls, larger cloud VMs, no training on business data by default, Codex access tokens for automation.
Enterprise / Edu	Contact sales	RBAC, SCIM, EKM, audit logs via the Compliance API, data residency, Codex Security for connected repos, priority processing.
API key	Usage-based	CLI, SDK and IDE only. No cloud features — no GitHub code review, no Slack, no cloud tasks.

How credits work

Once included usage is exhausted, everything is priced in credits per million tokens, split across input, cached input, and output. The rates published by OpenAI at the time of writing:

Model	Input / 1M	Cached input / 1M	Output / 1M
GPT-6 Astra	250 credits	25 credits	1,250 credits
GPT-5.6 Sol	100 credits	10 credits	500 credits
GPT-5.6 Terra	50 credits	5 credits	300 credits
GPT-5.6 Luna	5 credits	0.5 credits	30 credits
GPT-5.4	62.5 credits	6.25 credits	375 credits
GPT-5.4 mini	18.75 credits	1.875 credits	113 credits

A typical GPT-5.6 message lands somewhere between 5 and 30 credits. Fast mode multiplies consumption — for Astra it applies a 2.5× multiplier on the standard rate. Image generation burns included limits roughly three to five times faster than an equivalent text turn. Desktop voice costs $0.05 per minute, or 1.25 credits per minute on credit-billed workspaces.

Two scheduling notes for anyone planning a rollout: Sol's promotional pricing is guaranteed only through 21 November 2026, and GPT-5.5 retires from ChatGPT and Codex on all plans on 14 October 2026 (the API is unaffected).

What a developer actually spends

OpenAI's own rate-card documentation puts average Codex spend at roughly $100 to $200 per developer per month, with wide variance driven by model choice, concurrent instances, automations and fast mode. That figure is worth sitting with, because it is two to ten times the sticker price of the plan most teams start on. For context, the equivalent figure in Anthropic's documentation for Claude Code is $150–$250 per developer per month on API billing — the same order of magnitude, which tells you something about agentic coding as a category rather than about either vendor.

Limits are enforced on a rolling five-hour window rather than a daily cap, with weekly limits layered on top. Local message estimates per five-hour window, from OpenAI's pricing page:

Model	Plus	Pro 5×	Pro 20×
GPT-6 Astra	5–45	25–225	100–900
GPT-5.6 Sol	10–100	50–500	200–2,000
GPT-5.6 Terra	25–200	125–1,000	500–4,000
GPT-5.6 Luna	250–2,000	1,250–10,000	5,000–40,000

The spread between the lower and upper bound is adaptive — the low end is what you can count on under load. Standard Business seats use the Plus estimates; the $100 Business tier uses Pro 5× estimates.

Five things that actually reduce the bill

Match the model to the job. Routing routine work to Terra or Luna instead of Sol changes cost by an order of magnitude. Luna's output rate is one-sixteenth of Sol's.
Trim AGENTS.md. Nest instruction files per directory rather than maintaining one root file that every task pays for.
Turn off unused MCP servers. Each one is a standing tax on every message.
Scope tasks before delegating. Long unsupervised runs are the product's best feature and its worst cost profile; a vague prompt means the agent explores instead of executing.
Watch the usage dashboard for the first month. If overage credits appear consistently on top of Plus, price out Pro rather than topping up in small increments.

Pros and cons

Strengths	Trade-offs
Genuinely long-horizon: it will grind through a multi-file refactor, run the test suite, and iterate — not just autocomplete.	Token-credit billing makes budgeting harder than a flat per-seat tool. Two similar-looking tasks can differ by 10× in cost.
Real cloud portability. Bedrock, Azure OpenAI and (via Universal Credits) OCI all let you keep spend and data inside an existing contract.	Every cloud-provider route disables the cloud-only features — GitHub code review, Slack, cloud tasks, the plugin store.
Deep enterprise controls: SSO, SCIM, RBAC, audit logs, managed config policies, workload identity federation, data residency.	Most of those controls are Business or Enterprise only, which is a real jump from a $20 Plus seat.
Codex Security brings vulnerability triage into the same agent that writes the fix.	The cloud Security service is Enterprise-tier; smaller teams get the plugin and CLI only.
Bundled with ChatGPT, so many teams already own it without a new procurement cycle.	Conversely, you cannot buy "just Codex" cleanly — new Business signups can no longer take Codex-only pay-as-you-go seats.
Model choice within one harness: Astra for hard problems, Terra for production work, Luna for volume.	Model availability varies by authentication route. A Bedrock or Azure deployment exposes a narrower catalogue than ChatGPT sign-in.

Cloud integration: AWS, Azure, Google Cloud, OCI

This is where 2026 genuinely changed the picture, so it is worth stating the mechanism plainly.

Until April 2026, Microsoft held exclusive rights to distribute OpenAI's API-accessible products through a cloud. On 28 April 2026 that agreement was amended; the following day AWS announced OpenAI models, Codex, and Managed Agents on Amazon Bedrock. On 10 June 2026, OpenAI and Oracle announced that eligible Oracle Universal Credits can be applied to OpenAI models and Codex through OCI. Google Cloud remains the outlier.

Across all four, there are really two integration patterns, and conflating them is the most common planning error:

Pattern A — the cloud hosts the model. Codex runs locally, but inference is served by your cloud provider under your IAM, your logging, your commit. This is Bedrock and Azure OpenAI.
Pattern B — the cloud hosts the work. Inference goes to OpenAI, but the agent executes on your infrastructure and authenticates with your cloud's identity system instead of a long-lived API key. This is the Google Cloud story, and it complements Pattern A everywhere else.

Amazon Web Services: Codex on Bedrock

The Bedrock integration is the most complete Pattern A implementation available. Codex runs locally in the CLI, desktop app or VS Code extension; Bedrock is configured as the model provider; authentication uses a Bedrock API key or AWS IAM credentials. The OpenAI-hosted Responses API is not in the request path at all — Bedrock provides its own OpenAI-compatible implementation.

What you inherit by doing it this way: IAM-based access control, AWS PrivateLink, Bedrock Guardrails, encryption at rest and in transit, CloudTrail logging, regional control, and Bedrock quotas. Eligible customers can apply Codex usage toward existing AWS cloud commitments — which for many enterprises is the entire argument.

Prerequisites at the time of writing: Codex CLI 0.128.0 or later (or desktop/VS Code build 26.429.30905+), access to supported OpenAI models in Bedrock, and a region where your chosen model is available. Model IDs are Bedrock-namespaced, for example openai.gpt-5.6-sol.

# ~/.codex/config.toml
model = "openai.gpt-5.6-sol"
model_provider = "bedrock"

[model_providers.bedrock]
name = "Amazon Bedrock"
wire_api = "responses"
# Auth resolves from the standard AWS credential chain
# (IAM role, SSO profile, or a Bedrock API key).

What Bedrock does not give you. Features that depend on OpenAI-hosted services are unavailable in this configuration: image generation, voice transcription for input, the cloud plugin store, and cloud-managed configuration and policy management. Codex cloud tasks, GitHub PR review and Slack are separate contracts tied to ChatGPT sign-in, not unlocked by a Bedrock key. Codex on Bedrock launched in limited preview — confirm your account's access before designing around it.

AWS also offers Bedrock Managed Agents, powered by OpenAI models and OpenAI's agent harness, running on AgentCore. That is a different product from Codex — it is for deploying production agents, not for coding — but it shares the underlying procurement path, which matters if you are writing one business case for both.

Microsoft Azure: Codex on Azure OpenAI in Foundry

Azure has supported this route the longest and it remains the most mature. You deploy a reasoning model from the Microsoft Foundry catalogue — gpt-6-astra, gpt-5.6-sol, gpt-5.3-codex, gpt-5.2-codex, gpt-5.1-codex-max and others are documented — then point the Codex CLI or VS Code extension at that deployment. The agent runs entirely on Azure infrastructure, inside your compliance boundary, with private networking and Azure RBAC.

The configuration detail that causes most of the support tickets: model must be your Foundry deployment name, not the public model family name, and base_url must end in /openai/v1 without a trailing /responses — Codex appends that itself when wire_api = "responses".

# ~/.codex/config.toml
model = "gpt-5-6-sol-prod"        # your Foundry deployment name
model_provider = "azure"
model_reasoning_effort = "high"

[model_providers.azure]
name = "Azure OpenAI"
base_url = "https://YOUR-RESOURCE.openai.azure.com/openai/v1"
env_key = "AZURE_OPENAI_API_KEY"
wire_api = "responses"

[projects."/Users/you/projects/myapp"]
trust_level = "trusted"

Model availability on Azure varies by region, quota and subscription — codex-family models have historically landed in a small number of regions first. Check the Foundry region availability table before you commit an architecture to a specific model. For production, prefer Microsoft Entra ID authentication over a static AZURE_OPENAI_API_KEY; OpenAI also supports Azure as a workload identity provider, covered below.

Google Cloud: the Pattern B story

Be clear-eyed here: as of writing, Vertex AI's Model Garden offers OpenAI's open-weight gpt-oss 120B and gpt-oss 20B as managed serverless APIs — not the GPT-5.6 or GPT-6 frontier models, and not a supported Codex provider route. There is no Google Cloud equivalent of Codex-on-Bedrock.

That does not make Codex a poor fit for a GCP shop. It changes the integration shape:

Run the agent on GCP, authenticate with GCP. Use Google Cloud workload identity federation so a GKE workload or Cloud Build job exchanges a Google-issued OIDC token for a short-lived OpenAI access token. No static keys in Secret Manager, no key rotation runbook.
Give Codex GCP context through MCP. Connect MCP servers that expose BigQuery, Cloud Logging, or your own platform APIs so the agent can read schema and logs rather than guess at them.
Keep inference egress explicit. Use OpenAI's published IP egress ranges and, on Enterprise, Private Link and IP allowlisting to make the traffic auditable in your VPC Service Controls posture.
If you need frontier inference inside GCP for a non-Codex workload, that is a Gemini or open-weights decision, not a Codex one. Plan the two separately.

In practice, many GCP teams run Codex for the agent and keep their cloud-native assistant for infrastructure-specific work. That is a defensible architecture, not a compromise.

Oracle Cloud Infrastructure: the procurement play

Oracle's integration is commercially interesting rather than technically novel. Announced 10 June 2026, eligible Oracle Universal Credits can be applied to OpenAI frontier models and Codex through OCI, with the offering surfaced via OCI Marketplace. For organisations carrying large prepaid Oracle commitments — particularly those with underconsumed, expiring balances — this converts stranded commitment into AI spend without opening a new vendor contract, security review, or procurement cycle.

Two things to pin down in writing before you build a plan around it:

"Eligible" is doing a lot of work in that sentence. Neither party has published which credit pools, discount tiers, or per-token rates apply. Get it specified in your order document.
Expect a commitment conversation. AI consumption forecasts are an effective instrument for selling a larger, longer Oracle commitment. If you negotiate, try to keep the AI credit language model-agnostic so the money follows your future model choice rather than locking you to one vendor.

Separately, OCI Generative AI has supported OpenAI's gpt-oss-120b and gpt-oss-20b since November 2025, on demand and on dedicated AI clusters — useful for self-hosted inference workloads, but not a Codex provider route. For CI running in OCI, use OCI workload identity federation.

Side-by-side

Capability	AWS	Azure	Google Cloud	OCI
Frontier models hosted in-cloud	Yes (Bedrock)	Yes (Foundry)	No — open-weights only	Via Marketplace / API access
Codex as a native provider route	Yes (limited preview)	Yes (GA, most mature)	No	Commercial access; confirm route
Pay from existing cloud commit	Yes	Yes (Azure subscription)	No	Yes (Universal Credits)
Workload identity federation	Yes (STS + EKS)	Yes (Entra)	Yes (GCP + GKE)	Yes
Private networking	PrivateLink	Private endpoints	Egress ranges / Private Link	OCI networking
Codex cloud features retained	No	No	Yes (ChatGPT sign-in unaffected)	Depends on route

Workload identity: killing API keys in CI

The single most underrated Codex feature for platform teams is workload identity federation. Instead of storing an OPENAI_API_KEY in your CI secret store, a workload presents a cloud-issued OIDC token and receives a short-lived OpenAI access token in exchange. Supported providers include AWS (both STS outbound federation and EKS projected service-account tokens), Microsoft Azure, Google Cloud, Oracle Cloud Infrastructure, generic Kubernetes, GitHub Actions, SPIFFE, and X.509 certificates.

The AWS flow is representative. Enable outbound identity federation on the account, then scope an IAM policy tightly:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": "sts:GetWebIdentityToken",
    "Resource": "*",
    "Condition": {
      "ForAllValues:StringEquals": {
        "sts:IdentityTokenAudience": "https://api.openai.com/v1"
      },
      "NumericLessThanEquals": { "sts:DurationSeconds": 300 }
    }
  }]
}

TOKEN=$(aws sts get-web-identity-token \
  --audience "https://api.openai.com/v1" \
  --signing-algorithm ES384 \
  --duration-seconds 300 \
  --query "WebIdentityToken" --output text)

You then create a Workload Identity Provider in OpenAI pointing at the AWS account-specific issuer URL, and a service account mapping that matches on the sub claim — the exact IAM role ARN, which is the strongest available isolation. Mapping-level permissions such as api.model.request narrow what the minted token can do beyond the service account's own scope.

Practical notes worth knowing before you start: GetWebIdentityToken is not available on the global STS endpoint, so configure a regional one. Nested AWS claims live under a namespaced key and need a CEL attribute transformation before you can match on them. And for EKS, read the projected token from its mounted path on every exchange so rotation is picked up automatically.

For Codex specifically, the CLI reads the federated token from a file — see OpenAI's Codex workload identity setup, which is a separate configuration step from the API SDK flow above.

Codex vs. the competition, with prices

Prices below are published list rates gathered in September 2026. Every vendor in this table has changed pricing at least once in the past year, so verify before you budget.

Tool	Shape	Entry price	Team / enterprise	Cloud fit
ChatGPT Codex	Agentic harness across CLI, IDE, desktop, cloud	$0 Free / $8 Go / $20 Plus	$20–25 per user; Pro $100–$200	AWS Bedrock, Azure Foundry, OCI credits
Claude Code — our review	Terminal-first agent, IDE and CI surfaces	$20/mo (Pro)	Max $100 / $200; Team & Enterprise seats	Bedrock, Vertex AI, Microsoft Foundry
GitHub Copilot	IDE-embedded completion plus agents, deepest GitHub integration	$0 Free / $10 Pro	$19 Business, $39 Enterprise, $100 Max	Strongest where GitHub is the hub; Azure-adjacent
Cursor	AI-native editor with multi-file agent	$0 Hobby / $20 Pro	Pro+ $60, Ultra $200, Teams ~$40/seat	Cloud-agnostic; model choice across providers
Gemini Code Assist	IDE plugin plus Gemini CLI, 1M-token context	Free/individual tiers ended June 2026	$19 Standard, $45 Enterprise	Best fit for Google Cloud-native teams
Amazon Q Developer	IDE plugin with AWS-specific tooling (IAM, CloudFormation, Java upgrades)	Free tier (capped agentic requests)	$19/user Pro	Deepest AWS toolchain integration
Oracle Code Assist	IDE assistant tuned for Oracle DB, Java, Fusion workloads	—	~$19–$39/dev indicative list; negotiable against Universal Credits	OCI-native, OCI Generative AI underneath
Tabnine	Enterprise assistant, air-gapped deployment option	—	~$39–$59/user, annual commitment	The realistic choice under strict zero-retention rules

What the table does not show

Three observations that matter more than the price column.

The interface axis has collapsed. Codex, Claude Code, Copilot and Cursor all now ship a CLI, all execute agentically, all run cloud agents that open pull requests, and all speak MCP. Choosing on "terminal versus IDE" is choosing on a distinction that stopped existing. The real differentiators are model access, where execution happens, and what the agent can reach outside the repository.

Per-seat pricing and agentic pricing are different products. Copilot at $10 and Codex at $20 are not comparable line items, because Copilot's completions do not consume credits while Codex's every action does. A team of twenty running Copilot for completions costs $200/month with high confidence. The same team running agents all day costs somewhere between $2,000 and $4,000 and you will not know which until month two.

Most mature teams run two tools. Autocomplete and delegation are genuinely different jobs, and the vendors have stopped pretending otherwise — paid Copilot plans can now hand tasks to Codex and Claude agents from inside GitHub. Keeping a cheap completion tool for flow and one agentic tool for delegated work is usually cheaper and better than forcing either into the other's role.

How to choose for your stack

Heavy AWS, with a Bedrock commit. Codex on Bedrock is the strongest argument in this article. Inference under your IAM, logged in CloudTrail, billed against your commit. Pair with Amazon Q Developer for IAM and CloudFormation work it does better.
Azure-centric or Microsoft-shop. Codex via Foundry is the most mature route and the compliance story is the cleanest. Entra for identity, private endpoints for the network, existing Azure spend for the bill.
Google Cloud native. No frontier Codex route in-cloud. Either accept OpenAI-hosted inference with GCP workload identity federation for the CI path, or standardise on Gemini Code Assist and use Codex selectively where the agent is clearly better.
Large Oracle commitment. Investigate the Universal Credits route seriously, and get "eligible" defined contractually before it appears in a forecast.
Regulated with zero-retention requirements. Codex Enterprise plus a cloud provider route covers most of it — data residency, retention controls, EKM, no training on business data. If you need fully air-gapped, that is still a different product category.
Solo developer or small team. Start on Plus at $20 and watch the usage dashboard for a month. Do not buy Pro until overage tells you to.

Frequently asked questions

Is ChatGPT Codex free?

There is a Free tier for exploratory use, and Codex is included in every paid ChatGPT plan from Go ($8) upward. There is no standalone Codex subscription. The cloud agent features that make Codex most useful — background tasks, GitHub PR review, Slack — start at Plus ($20/month).

How much does Codex cost per developer per month in practice?

OpenAI's rate-card documentation cites roughly $100 to $200 per developer per month on average, varying significantly with model choice, number of concurrent instances, automations and fast mode. Budget against that figure rather than against the plan price.

Can I run Codex on AWS without sending data to OpenAI's API?

Yes, using Codex with Amazon Bedrock. Codex runs locally, Bedrock serves inference through its own OpenAI-compatible Responses API implementation, and the OpenAI-hosted API is not in the request path. You lose the OpenAI-hosted cloud features — image generation, voice input, the cloud plugin store, and cloud-managed policy configuration.

Does Codex work with Azure OpenAI?

Yes. Deploy a supported reasoning model in Microsoft Foundry, then configure the Codex CLI or VS Code extension with model_provider = "azure", your deployment name as the model, a base URL ending in /openai/v1, and wire_api = "responses". The agent then runs entirely on Azure infrastructure inside your compliance boundary.

Is Codex available on Google Cloud Vertex AI?

Not as a provider route. Vertex AI offers OpenAI's open-weight gpt-oss 120B and 20B models, not the frontier models Codex runs on. GCP teams integrate through workload identity federation, MCP servers for cloud context, and network egress controls instead.

Can I pay for Codex with Oracle Universal Credits?

That is the intent of the June 2026 OpenAI–Oracle partnership: eligible Universal Credits applied to OpenAI frontier models and Codex through OCI and OCI Marketplace. Confirm which credit pools qualify and at what rates with your Oracle account team before assuming coverage.

Codex or Claude Code?

They are closer than the marketing suggests, and both land in the same $100–$250 per developer per month range under real agentic use. Codex has the edge if you are AWS or Azure-committed and want inference inside that contract, or if your organisation already runs on ChatGPT Enterprise. Claude Code has the edge if you want Vertex AI as a provider option or prefer flat subscription tiers over token credits. Our Claude Code review covers that side in detail.

What happens when I hit my usage limit mid-task?

Work already in progress can continue through the active turn, subject to fair-use limits. Plus and Pro users can purchase additional credits without upgrading; Business, Edu and Enterprise workspaces on flexible pricing can buy workspace credits. Switching to a smaller model is the cheapest way to extend a window.

References

Pricing and feature details for every product mentioned here change frequently. Confirm current numbers on each vendor's official pricing page before making a purchasing decision. Codex on Amazon Bedrock and several OCI details were in preview or early rollout at the time of writing.