What Codex Is (and Isn't)

Before any commands, install scripts, or model names, lock in one idea, because the entire course rests on it: Codex is an agent, not an autocomplete.

An autocomplete tool watches your cursor and offers the next line. You are still doing the work — reading the codebase, deciding what to change, opening files, running the tests, fixing what broke. The tool just types a little faster than you would.

Codex works the way a capable engineer does. You hand it a goal in plain language — "add rate limiting to the login endpoint and update the tests" — and it reads the relevant parts of your repo, proposes a plan and the commands it wants to run, edits files, runs the tests, reads the failures, fixes them, and can open a pull request. OpenAI describes it as "OpenAI's coding agent for software development," used by developers to "write, refactor, debug, test, and validate code across large codebases." It is doing the loop you would otherwise run by hand, not predicting your next keystroke.

That shift — from suggesting lines to executing tasks — is the whole reason the product exists. It is also why the skills you'll learn in this course (steering it, scoping work, reviewing diffs, setting approvals) look more like delegating to a teammate than configuring an editor plugin.

An agent that can edit files and run shell commands sounds alarming until you see the two properties that make it trustworthy rather than reckless. Both are core to what Codex is, so meet them on day one.

• It asks permission. Codex does not silently rewrite files or run arbitrary commands. Depending on its approval mode it pauses and asks before going beyond safe, read-only actions, showing you exactly what it wants to do. When it asks is controlled by an approval policy; where it is allowed to act is controlled independently by a sandbox. (Those two controls get a full lesson of their own later — for now, just know they exist and are separate.)
• It stays steerable. You are never locked out mid-run. In the terminal, Ctrl+C cancels the current turn so you can redirect; pressing Esc twice on an empty composer lets you edit your previous message and fork the conversation from there. You correct course instead of starting over.

Codex always surfaces a transcript of everything it did, and it has no /undo command — you roll back the way you already roll back code, through your normal git workflow. That is a deliberate design choice: the agent leaves an auditable trail and leans on version control rather than a private, hidden undo stack.

Neither the asking nor the steering makes Codex slow. It makes Codex delegable: you can hand it real work without flying blind, because nothing consequential happens without your say-so and every action is visible.

Here is the single biggest source of confusion for newcomers: three completely different things have been called "Codex." When you read an article, the date tells you which one it means. Get this straight once and older blog posts will never mislead you.

The punchline: the 2021 "Codex" is a dead model; the 2026 "Codex" is a live agent. They share nothing but a brand. If someone points you at code-davinci-002, the 2023 API-shutdown news, or a "Codex powers Copilot" article, that is the first product — interesting history, irrelevant to using the agent.

The version you'll actually use was born on May 16, 2025, when OpenAI reused the Codex name for a cloud-based software-engineering agent that could work on many tasks in parallel. At launch it was a research preview, available first to ChatGPT Pro, Business, and Enterprise, with Plus following shortly after (~June 3, 2025).

That first agent was powered by codex-1 — described by OpenAI as "a version of OpenAI o3 optimized for software engineering," trained with reinforcement learning on real coding tasks. Each task ran in its own isolated cloud sandbox preloaded with your repository, and most tasks took roughly 1–30 minutes. The open-source Codex CLI (a local terminal agent) arrived around the same period, and the surface set expanded through 2025–2026.

The model lineage then evolved, and this is where you must be careful, because model names rot fast:

codex-1  (May 2025, an o3 variant)
   │
   ▼
GPT-5-Codex
   │
   ▼
the GPT-5.x-Codex line  ← today

A quick guide to the naming convention so the catalog stays legible even as specific names change: plain gpt-5.x = frontier general models; the -codex suffix = optimized for agentic coding; -mini = small/fast (good for subagents); -spark = ultra-low-latency text-only previews. Which model is recommended by default changes over time, so don't memorize a version number — read it live.

The last piece of the mental model is the word umbrella. "Codex" is not a single app — it is the name for a family of surfaces that all share one underlying model family and one ChatGPT account context. OpenAI's own framing: there is one Codex, and the same agent and the same login follow you across the terminal, your editor, the cloud, the desktop app, your phone, and GitHub.

You don't need every surface yet — the next lesson tours them in detail. For now, hold three consequences of "one Codex":

• One agent, many entry points. The CLI in your terminal, the IDE extension, the web app at chatgpt.com/codex, the desktop and mobile apps, and the @codex GitHub bot are views onto the same agent, not separate products you have to learn five times.
• Tasks move between local and cloud. You can start a task in the CLI or IDE, delegate it to Codex Cloud to run in the background, then apply the resulting diffs back locally. Configuration like AGENTS.md (a cross-tool instruction file) travels with the repo.
• One metered product. Local messages and cloud tasks share the same plan usage — reinforcing that this is literally one tool with one bill, not a bundle of separate things.

That's the whole mental model: an agent (not an autocomplete) that acts under your permission and stays steerable, reachable through many surfaces that all share one model family and one account. Everything else in this course — install, approvals, AGENTS.md, MCP, the cloud — hangs off that frame.

Codex moves fast, so a lesson that hard-codes today's numbers is a lesson that's wrong next month. The durable skill is knowing which facts are stable and which are volatile, and where to check the volatile ones.

Stable (safe to internalize):

• Codex 2026 is an agentic SWE system that reads, edits, and runs code, runs tests, invokes tools, and proposes PRs.
• It needs permission to act and stays steerable; rollback is via git, not /undo.
• The three eras: 2021 model → 2023 shutdown → 2025 agent.
• It's an umbrella of surfaces sharing one model family and one ChatGPT account.

Volatile (verify live, don't memorize):

Mirror this discipline whenever you teach or document Codex: state the concept, then point at the live page instead of freezing a number that will rot.