Gold & Diamond Standard Edition — Verified against live sources, July 28, 2026

How this guide was built: Compiled on July 28, 2026 from OpenAI’s official documentation (developers.openai.com/codex — fetched live), OpenAI’s help center and pricing pages via current trackers verified July 22–28, and the Codex changelog. One honesty note: I’m Claude (built by Anthropic), so this is an outside-in synthesis of the public record on a competitor’s products — sourced carefully, but always confirm plan/pricing details at openai.com before spending money. OpenAI ships changes weekly; treat this as an accurate snapshot.

PART 0 — THE 30-SECOND MENTAL MODEL

ChatGPT in 2026 is no longer a chatbot — it’s a platform: chat, agents, research, coding, browsing, voice, video, memory, and 60+ app connectors under one login. Codex is the coding-and-computer-use agent inside that platform, spanning CLI, IDE, desktop app, web/cloud, GitHub, Slack, and mobile — all sharing one agent harness.

The two skills that unlock everything: (1) route the right model/tool to the right task (the Auto selector won’t always do it for you), and (2) delegate outcomes with verification, not step-by-step instructions.

PART 1 — THE MODEL FAMILY (Deep Dive, July 2026)

1.1 Current lineup at a glance

Timeline that matters: GPT-5.5 launched April 23, 2026 as OpenAI’s fully retrained agentic-first model and became Codex’s default. GPT-5.6 (Sol/Terra/Luna) launched July 9, 2026 after a June 26 preview — all three share a 1.05M-token context and 128K max output. Legacy models (GPT-4o, GPT-4.1, o4-mini, original GPT-5) were retired from ChatGPT on February 13, 2026. The o3 reasoning line still exists separately for some workloads.

1.2 Which model for what — the routing table

• Everyday chat, quick answers, drafting → GPT-5.5 Instant (it’s the default for a reason — fast and cheap for OpenAI, snappy for you).
• Hard reasoning, complex code, multi-step agent runs → GPT-5.6 Sol (pick it explicitly via reasoning settings/model picker; see the Auto-router warning below).
• Maximum accuracy, worth the wait → Sol Pro (Pro/Enterprise) or GPT-5.5 Pro.
• Production API at scale → Terra first; escalate to Sol on evidence, drop to Luna for classification/extraction/routing volume.
• Rapid-fire small coding edits in Codex → GPT-5.3-Codex-Spark (Pro preview).
• Set effort level per model where offered — low effort for simple tasks is a real cost/speed lever; reasoning tokens bill as output.

1.3 ⚠️ The Auto-router caveat (the most underrated fact in this guide)

In ChatGPT’s default Auto mode, OpenAI silently routes each message to Sol, Terra, Luna, or an older GPT-5.5 variant based on undocumented logic. On a hard prompt you get the flagship; on a routine one you may not — and the UI doesn’t show which model answered unless you dig into settings (API users always get the model ID in metadata). Power-user rule: for anything that matters, pick the model explicitly instead of trusting Auto. This is also why two people on the same $20 plan can have wildly different quality experiences.

PART 2 — CHATGPT: PLANS, AND EVERY FEATURE THAT MATTERS

2.1 Plans (July 2026)

Rollouts vary by account and region — check your own model picker before upgrading. Codex Mobile is free on every plan (even Free/Go) since May 14, 2026.

2.2 The feature arsenal — and when to reach for each

Memory + Projects (the highest-leverage combo). Memory (rebuilt as “Dreaming V3,” June 2026) holds durable facts about you — role, preferences, style. Projects are persistent workspaces holding context about a workstream — files (~40 on Plus), links, standing instructions, and automatic within-project memory across sessions. The canonical setup: Memory knows your role; each Project knows the client/codebase/course. Review Memory periodically — it’s imperfect.

Search vs. Deep Research. Search = quick current facts. Deep Research = a multi-step agent that plans (you can edit the plan before it runs), issues sequential queries, reads dozens of pages over 5–30 minutes, and returns a cited report. Since Feb 2026 it connects to any MCP server, so it can research your internal wikis and datastores alongside the web. Caveat: it synthesizes, it doesn’t verify — check citations on anything consequential.

Agent Mode / Operator. Agent Mode (Plus: ~40 messages/mo) hands ChatGPT a browser for multi-step web tasks — form filling, comparisons, bookings. Operator is the heavier-duty version on Pro $200.

Tasks (scheduled automation). One-off or recurring runs — daily briefings, inbox checks, monitors — without an open tab. Replaced the Pulse feature (sunset June 18, 2026). Active-task caps by tier (Go 3, Plus 5, higher tiers more).

Canvas. A live side-by-side document/code editor for long-form iteration — edit sections, get inline suggestions, run code. Use it whenever output exceeds a few paragraphs.

Data Analysis. Upload CSV/Excel; ChatGPT writes and runs Python for real calculations, charts, and cleaning. Also dedicated ChatGPT-in-Excel/Sheets integrations.

Voice, Record Mode, images, Sora. Advanced Voice for natural conversation; Record Mode transcribes/summarizes meetings; image input for screenshots; image generation for mockups/diagrams; Sora for video (unlimited only on Pro $200).

Custom GPTs, Skills, Apps/Connectors. Custom GPTs = repeatable assistants with instructions + knowledge files. Skills = reusable workflow definitions. Apps/connectors (60+: Drive, Slack, GitHub, Salesforce…) plus custom MCP servers pipe your real work context in — and MCP feeds Deep Research too.

Atlas & ChatGPT Work. Atlas puts ChatGPT inside the browser; ChatGPT Work (all plans on desktop) is the task-oriented workspace where Free/Go users can even reach GPT-5.6 Terra.

2.3 ChatGPT prompting mastery

The universal five-part skeleton — role, goal, context, constraints, format:

You are [role]. I need [specific goal].
Context: [audience, situation, what's been tried].
Constraints: [length, tone, exclusions, must-includes].
Format: [structure of the output].

The pattern in action (from the current power-user canon): “Write a 100-word email to B2B SaaS CTOs who attended our demo last week; goal is a scheduled follow-up call; peer-to-peer tone; no sales language; end with one easy question.” Specific inputs → usable output on the first pass.

Prefixes that consistently raise quality:

• “Ask me clarifying questions before answering” — the single best prefix for complex requests.
• “Think step by step, then give the final answer” — still effective on non-reasoning models; on reasoning models, raise the effort setting instead.
• “Here’s an example of what good looks like: […]” — few-shot beats description.
• “Act as a harsh critic of the draft above” — second-pass self-review.
• For Deep Research: state scope, sources to prefer/avoid, time bounds, and the exact deliverable structure — then edit the proposed plan before launching; it’s your one cheap steering moment.
• For Agent Mode: give the end state and guardrails (“stop and ask before any purchase/login”).

PART 3 — CODEX: THE COMPLETE PICTURE

3.1 What Codex is now

Forget the 2021 autocomplete API. Codex 2026 is OpenAI’s unified agent system — an agent loop + shared harness serving every surface, used by ~4M developers weekly. It clones or opens your code, plans, edits across files, runs commands and tests in sandboxes, iterates until green, and opens PRs. The April 16, 2026 “Codex for (almost) everything” update pushed the desktop app beyond code: background Computer Use on Mac (its own cursor while you keep working), an in-app browser, image generation, memory, and background Automations — positioning Codex as OpenAI’s agentic workspace, not just a coding tool.

3.2 Every surface

All surfaces share auth (ChatGPT login or OPENAI_API_KEY), config, and the AGENTS.md convention.

3.3 Getting started

npm i -g @openai/codex        # or brew install codex
codex login                    # browser OAuth (or device-code flow)
cd your-project && codex       # interactive TUI
codex "Explain this codebase to me"

API-key auth (OPENAI_API_KEY) works without OAuth — ideal for CI — though some cloud-thread features need the ChatGPT login. Config lives in ~/.codex/config.toml (profiles supported: codex --profile ci exec "…").

3.4 Approval modes & sandboxing (know these cold)

• Auto (default): read/edit/run freely inside the working directory; asks before going outside it or touching the network.
• Read-only: consultative; browses but changes nothing until you approve a plan.
• Full Access (--yolo): whole machine + network, no asking. Use rarely, only on trusted repos.

Switch with /permissions mid-session. Cloud tasks run in ephemeral, network-isolated sandboxes scoped to your repo. Auto-review adds a safety pass on the agent’s own changes. Web search defaults to a cached OpenAI-maintained index (reduces prompt-injection exposure from live pages); go live with --search or web_search = "live" — and still treat web content as untrusted.

3.5 AGENTS.md — Codex’s persistent brain

The equivalent of a project constitution: a markdown file Codex reads every session, with a documented hierarchy (global ~/.codex/AGENTS.md → repo root → subdirectory overrides). Fill it with build/test commands, style rules that differ from defaults, repo etiquette, and gotchas — and keep it lean; bloat gets ignored. Alongside it: Rules (deterministic constraints), Memories/Chronicle (Codex’s own accumulated learnings, with memory-mode controls), Skills (on-demand workflows like $imagegen), Hooks (scripts on lifecycle events with live activity display), Subagents (parallel workers configured under [agents] in config.toml — powerful, but explicitly documented to consume more tokens than single-agent runs, and only spawned when you ask), Plugins (installable from GitHub/git URLs via the marketplace), and MCP servers (codex mcp …; popular: Context7 docs lookup, Figma, Playwright, Chrome DevTools, GitHub, Sentry — and Codex can itself run as an MCP server inside another agent).

3.6 Command & shortcut reference

Slash commands (TUI): /model (switch mid-session) · /permissions · /review (inline code review presets: against a base branch, uncommitted changes, a specific commit, or custom instructions — never touches your working tree; great pre-commit check) · /fork · /side · /theme · /clear · /copy · /status · /exit · custom commands you author for team workflows.

Keyboard: @ fuzzy file search · !cmd run shell (output enters context) · Tab queue follow-up input for the next turn (prompts, slash commands, or ! commands) · Enter mid-run to inject instructions into the current turn · Esc Esc walk back and fork from a previous message · Ctrl+G draft in your $VISUAL/$EDITOR · Ctrl+R search prompt history · Ctrl+O copy last output · Ctrl+L clear screen without clearing the conversation.

CLI essentials:

codex resume [--last | --all | <SESSION_ID>]   # reopen sessions with full context
codex exec "fix the CI failure"                # non-interactive / scripting
codex exec resume --last "Implement the plan"
codex cloud                                    # triage cloud tasks from terminal
codex cloud exec --env ENV_ID --attempts 3 "…" # best-of-N cloud runs
codex -i screenshot.png "Explain this error"   # image input (comma-separate multiples)
codex --cd <path> --add-dir ../backend         # working root + extra writable roots
codex --model gpt-5.5                          # pin model at launch
codex features list|enable|disable <flag>      # feature flags (e.g. multi_agent)
codex app-server --listen ws://…  /  codex --remote wss://…   # remote TUI
codex completion zsh                           # shell completions

3.7 What Codex is best at (and worst at)

Sweet spot: asynchronous, bounded, independently testable work — dependency upgrades, test-coverage expansion, style migrations, doc generation from diffs, bug fixes from issue descriptions — and queuing many such tasks in parallel sandboxes while you review PRs. Weaker fit: interactive exploratory debugging and tasks dependent on external state, where a local agentic session (Codex CLI in interactive mode — or, candidly, tools like Claude Code) shines.

3.8 Codex prompting patterns that work

1. Scope like a ticket: files involved, expected behavior, how to verify. “Fix the login bug” fails; “Users report login fails after session timeout — check the token-refresh path, write a failing test that reproduces it, then fix it and run the suite” succeeds.
2. Make tests the contract. Codex’s lineage is literally trained to iterate until tests pass — give it tests to pass.
3. Pre-set the environment (official tip): activate venvs, start daemons, export env vars before launching so Codex doesn’t burn tokens probing.
4. Use /review before every commit — cheap, read-only, prioritized findings; customize (“Focus on accessibility regressions”).
5. Fork instead of arguing: after two failed corrections, Esc Esc back to the fork point and re-prompt with what you learned.
6. Cloud for breadth, CLI for depth: batch the bounded stuff to Codex Cloud (--attempts 3 on anything gnarly), keep exploratory work local.
7. Attach visuals (-i design.png) for UI work; ask for a screenshot-vs-spec comparison as verification.

PART 4 — THE COST MASTERY PLAYBOOK

4.1 Subscription-side savings

Buy the cheapest plan that covers your bottleneck feature, not the model badge: most knowledge workers cap out at Plus $20 (the honest consensus of every current guide). The $100 Pro exists specifically for people hitting Plus’s Codex/usage ceilings; the $200 Pro is essentially “the Sora + Operator tier.” Watch limit-based traps: Deep Research (~10/mo on Plus) and Agent Mode (~40 msgs/mo) are the quotas real users hit first — spend them on tasks worth 30 minutes of agent time, use plain Search otherwise. And remember the Auto-router: explicitly selecting the flagship on hard tasks is free quality you’re already paying for.

4.2 API-side savings (the big levers)

1. Model routing: Luna ($1/$6) → Terra ($2.50/$15) → Sol ($5/$30). Start low, escalate on evidence. Output tokens are 6x input on every tier — output-heavy work is where tier choice bites.
2. Prompt caching: 90% off cached input reads (Sol $0.50, Terra $0.25, Luna $0.10 per 1M). Structure prompts with a stable prefix (system prompt, tools, docs) and volatile suffix to maximize hits — the single biggest lever for agent workloads with big repeated prefixes.
3. Batch API: 50% off everything, asynchronous — for evals, backfills, bulk generation.
4. Flex processing: discounted, lower-priority compute for latency-tolerant jobs (and Priority processing when latency is the constraint, at a premium).
5. Reasoning effort: set reasoning_effort low for simple calls — reasoning tokens bill as output tokens.
6. Compaction & conversation state: use the Responses API’s context-management features instead of resending ever-growing transcripts.

4.3 Codex-specific savings

Keep the environment pre-warmed (probing costs tokens). Use subagents only when parallelism genuinely pays — they’re documented to cost more than single-agent runs. Prefer /review (read-only, one pass) over “re-do it” loops. Cached web search is default and cheaper/safer than live. Image generation inside Codex burns included limits 3–5x faster than normal turns — for batches, set OPENAI_API_KEY and route through the API instead (official recommendation). Fork early rather than accumulating failed-correction context. In cloud, --attempts multiplies cost linearly — reserve best-of-N for genuinely hard tasks.

PART 5 — CHATGPT vs CODEX: WHICH TOOL FOR WHICH JOB

PART 6 — SAFETY, GOVERNANCE & FAILURE PATTERNS

Safety: never --yolo on untrusted repos; treat web content and issue text as prompt-injection surfaces (cached search default exists for exactly this); review agent transcripts — Codex always surfaces one, and git is your rollback; Enterprise gets managed configuration, governance, access tokens, and Lockdown Mode; the Codex Security plugin/cloud adds a dedicated vulnerability-review layer.

Failure patterns → fixes: trusting Auto on hard prompts → pick the model. Vague tickets → scope + verification criteria. Correction spirals → fork (Esc Esc) with a better prompt. Burning Deep Research quota on Search-sized questions → downshift. Memory drift → review and prune Memory; keep workstream context in Projects. Bloated AGENTS.md → prune like code. Subagents everywhere → single agent unless parallelism pays. Unverified research → click the citations.

PART 7 — CANONICAL RESOURCES

Codex (official): developers.openai.com/codex (overview, quickstart, pricing, prompting, models) · /codex/cli/features, /codex/cli/reference, /codex/cli/slash-commands · /codex/guides/agents-md · /codex/mcp, /codex/skills, /codex/subagents, /codex/hooks · /codex/cloud · /codex/learn/best-practices · /codex/changelog · github.com/openai/codex (open source, releases) ChatGPT: help.openai.com (release notes, feature articles) · openai.com/chatgpt/pricing · chatgpt.com API: developers.openai.com/api/docs — prompting & prompt-engineering guides, reasoning best practices, prompt caching, batch, flex processing, cost & latency optimization · platform.openai.com (dashboard) · openai.com/api/pricing

Compiled July 28, 2026. Fastest-moving details — GPT-5.6 rollout by plan/region, Deep Research and Agent Mode quotas, Task limits (OpenAI’s own docs are currently inconsistent above Plus), and Codex CLI versions (shipping near-weekly) — deserve a fresh check at the official links above before you commit budget.