Glossary
📚 Series Navigation: The previous article [37 Troubleshooting] helped you eliminate the error reports, stuck moments, and strange behaviors most commonly encountered when running Codex one by one. This article is used differently—it is not meant to be read from start to finish, but to be flipped through at any time: compiling all the terms that have appeared throughout the book into a portable dictionary. If you don't remember a word well, just look it up. The next article [39 Enterprise Management and Governance] will discuss how to manage Codex at the team and company level.
Brothers, by the time we get to this point in our tutorial, we have already thrown out a truckload of terms.
Agentic loops, Sandboxes, Approvals, Reasoning Effort, service_tier, MCP, Subagents, Skill, Hook... When I first systematically learned this type of tool, the most discouraging part was this—it's not that any single concept is too difficult, but that there are too many nouns, and they overlap with each other. By the time you see the tenth one, the first five have already blurred together.
To be honest, being discouraged by terminology is a common problem for beginners; it has nothing to do with being smart or stupid. The solution is also simple: don't memorize, just look them up. When you actually need a word, come back and take a look, then carry on with your work—after looking it up three to five times, it will naturally stick in your head.
This article is the portable dictionary prepared for you. It is grouped by theme, with each word explained in plain English, supplemented by "what it actually means in Codex" or an analogy. There's no need to read from the beginning—just Ctrl+F to search for the word you're stuck on, and leave after reading.
After reading this article, you will get:
- A Codex terminology dictionary grouped by theme, where every word is explained in plain language that beginners can understand
- A clear explanation of basic concepts (Agentic loop, Context Window, token), which form the foundation of all other concepts
- A centralized lookup for Codex-specific terms (
AGENTS.md,codex exec, Sandbox, Approval, Reasoning Effort,service_tier, Chronicle) - A one-sentence distinction of the five-piece extension suite (MCP, Subagent, Skill, Hook, Plugin), so you will no longer get them confused
- The positioning and distinction of the model family (the
gpt-5.5series), what "Research Preview" means, and which two have been deprecated and should no longer be used
⚠️ The commands, configuration keys, and default behaviors in this article are based on the Codex official documentation; things like model names and plan scopes that change with versions should always be based on what is actually displayed on your local
/modelpanel and incodex --helpat the time you view them—do not memorize the names.
01 Basic Concepts: The Foundation of All Terms
This group consists of "species-level" concepts—not just Codex, but almost all AI programming tools cannot avoid them. Get a solid grasp on these three first, so that the subsequent words can be easily connected.
Agent (also known as Intelligent Agent)
In one sentence: An AI that can decompose tasks, call tools, inspect results, and decide on the next step by itself, rather than a question-and-answer chat box.
What it means in Codex: Codex is OpenAI's "programming Agent". It can read code, modify files, run commands, and run tests all by itself while you just watch. This is a different species from the chatbot you usually use—a chat box will only reply with a piece of text, whereas an Agent will finish the entire job.
Agentic Loop
In one sentence: The basic rhythm of an Agent's work: Think → Do → Observe, and repeat if one round is not enough.
Analogy: A plumber. He doesn't just take a look, quote a price, and leave—first he "thinks" (where is it leaking?), then he "does" (tightens it, replaces a washer), and then he "observes" (turns on the water to see if it still leaks); if not, he goes back and tightens it again. The way Codex works is this loop: reading files, modifying code, running checks, and if validation fails, starting another round until it's done. This mechanism is exactly the same as Claude Code, just under a different shell.
Context Window
In one sentence: The total amount of information the model can "see at the same time" at once. It has a limit, and once it is filled, earlier content will be squeezed out.
Analogy: An office desk. The desk is only so big, and the documents you can spread out are limited. As new files are laid out, the earliest ones are pushed to the edge or even fall to the floor—when the model "forgets" what was said before, it is mostly due to this. Therefore, chatting for too long or stuffing in too much irrelevant content will actually make it perform worse. This is also the reason why subagents exist: to move noisy intermediate products off the main desk.
token
In one sentence: The smallest pricing unit for the model to process text, roughly "a word or half a word", and both your inputs and outputs are counted by it.
What it means in Codex: Two things are directly linked to it—quota and money. Subscription plans give you quota based on token usage, and API keys burn money directly by token; the unit price of flagship models is several times that of lightweight models. The "size" of the Context Window is also measured in tokens.
| Term | Remember in One Sentence |
|---|---|
| Agent | An AI that does hands-on work by itself, not just replying to you |
| Agentic Loop | Think → Do → Observe, and repeat if one round is not enough |
| Context Window | The total amount of information it can see at one time, which has a limit |
| token | The smallest unit for measuring text, related to quota and money |
💡 Summary in one sentence: These four are the foundation—the Agent does the work itself, the loop is its rhythm, the Context Window is its desk size, and the token is the ruler for pricing.
02 Codex-Specific Concepts: The Unique Terms of This Tool
This group is Codex's own special ingredients, and is also the source of why beginners feel it is "sometimes working, sometimes not". Once you understand them, you will no longer feel that Codex behaves erratically.
AGENTS.md (Project Instruction Manual)
In one sentence: A markdown file put into the project to write down the rules of your project, which Codex reads before starting work each time.
Analogy: A sticky note pasted on a workspace. You wouldn't chase colleagues every day chanting "we use pnpm, not npm"—you write a sticky note and paste it there for them to read themselves. AGENTS.md is the sticky note for Codex: how to run builds, how to run tests, and how to choose names; write it once, and it reads it first every time. It can be placed globally (~/.codex/AGENTS.md) or in the project root directory, and the closer it is to the working directory, the higher its priority (it is roughly equivalent to Claude Code's CLAUDE.md with a different name).
codex exec (Non-interactive Command)
In one sentence: A running method that does not enter the interactive interface, but directly "gives a single sentence and gets a single result", specifically designed for scripts and automation.
Analogy: A vending machine. The regular interactive mode is like chatting with a clerk—you ask a question and they answer, back and forth for several rounds. codex exec is like inserting coins to buy water: insert money, press the button, get the product, all in one go with no small talk. What goes into CI, scheduled tasks, and batch scripts is mostly this command.
Sandbox
In one sentence: A boundary drawn for Codex; it does things within the circle by itself, and must ask you first before going outside the circle.
Analogy: A playground fence. Play on the slide inside the fence as much as you want without being watched; if you want to climb out and run onto the road, someone has to stop you. The Sandbox controls two things—which files it can modify, and whether it can access the network. Common three levels: read-only (read-only, nothing can be touched), workspace-write (workspace writeable, the daily default, can only modify things in the directory where you started Codex, and network access is disallowed by default), and danger-full-access (full access, the name contains danger for a reason, use with caution).
Approval (Approval Policy)
In one sentence: Whether Codex stops to ask you when it wants to "go out of bounds"—this is another knob side-by-side with the Sandbox.
Analogy: The temper of the security guard at the door. The Sandbox is the door itself, and Approval is whether the guard is relaxed or strict. untrusted only blocks unfamiliar commands; on-request defaults to working inside the circle and only asks you when going out of bounds (the most commonly used balanced level); never works silently without bothering you. Remember: Sandbox controls "whether it can", and Approval controls "whether it asks"—do not confuse these two dimensions.
Reasoning Effort (configuration key model_reasoning_effort)
In one sentence: A knob that lets the model decide "how long to think before doing"; thinking longer is usually more accurate, but slower.
Analogy: The exam time given to write answers. For the same straight-A student, letting them answer at a glance versus letting them scratch out drafts and verify repeatedly yields worlds of difference in quality, but the latter is obviously much slower. Five levels: minimal (almost no thinking, instant reply), low, medium, high, xhigh (highest level, depending on whether the model supports it). If you are not satisfied with the results, don't rush to change models first—turning it up by one level often solves it; if you think it is too slow, turn it down by one level.
Reasoning Summary (configuration key model_reasoning_summary)
In one sentence: How much of its "thinking process" you want to see.
What it means in Codex: The values are auto / concise / detailed / none. If you want to see how it thinks step-by-step, set it to detailed; if you feel it clutters the screen, set it to none to turn it off directly. This is a pure user experience switch and has nothing to do with the quality of the results.
Service Tier (service_tier)
In one sentence: Prioritize your requests—whether to prioritize saving money or prioritize speed.
Analogy: Standard and express delivery. fast is explicitly defined by the officials as "adding credits to speed up the model by 1.5x", like express delivery paying extra to guarantee timing; flex is more of a conventional level with no extra acceleration. If you are in a hurry and don't care about that tiny credit consumption, you can try fast, otherwise the default is fine.
config.toml (Configuration File)
In one sentence: The main configuration file of Codex, located at ~/.codex/config.toml, in TOML format.
What it means in Codex: The knobs mentioned above—default model, Reasoning Effort, Sandbox mode, Approval policy, MCP server—if you want them to take effect every time you start up, write them into this file. Use slash commands for temporary changes, and write here for permanent changes.
Chronicle / Memory
In one sentence: Lets Codex remember your previously discussed preferences and project conventions, saving you from explaining them every time.
What it means in Codex: Memory is turned off by default; it must be enabled by writing memories = true in the settings or in the [features] section of config.toml, and it has regional restrictions and is stored locally. Chronicle is an experimental Research Preview, going one step further—using the content on your screen to help it understand what you have been busy with lately, currently only available for ChatGPT Pro, and only on macOS. A word of advice: for rules that absolutely must take effect every time, write them into AGENTS.md—do not rely on memory to save the day.
When I first started using Codex, the first thing I got tripped up on was the Sandbox—when I asked it to rename files in batches, the two files on my desktop didn't budge at all. I thought it was being picky, but after looking through the documentation, I realized workspace-write had fenced them outside my project directory. The pair you should memorize first in this group is Sandbox and Approval; they explain 80% of Codex's "why it refuses to move".
💡 Summary in one sentence: Among Codex-specific terms, Sandbox + Approval control permissions,
AGENTS.mdcontrols rules, Reasoning Effort controls "how long to think", andcodex execcontrols automation—all written intoconfig.tomlto take effect permanently.
03 Extension Capabilities: Connecting Codex's Abilities Outdoors
Basic and specific concepts are Codex's "body", and this group is about "adding gear" to it—the five terms look somewhat similar and are the most easily confused, so I will lock each one down with a single sentence.
MCP (Model Context Protocol)
In one sentence: A unified standard that allows Codex to connect to various external tools—databases, designs, browsers, and third-party services.
Analogy: A USB interface. By default, Codex can only reach local files and commands, but cannot reach your Figma, latest documentation, or online databases. MCP is that unified interface: connect it once, and a whole bunch of external tools are placed right in front of it. There is no need to write docking code for each tool individually, which is exactly the value of a "standard".
Subagent
In one sentence: A small Agent temporarily dispatched from the main conversation to work on a specific task in parallel; each works independently and only reports a summary back.
Analogy: Several runners running errands separately. If you (the main line) want to review a change from three aspects—security, performance, and testing—there is no need to inspect them three times sequentially yourself. Dispatch three runners at the same time, and let each return with a summary. Key point: Codex never automatically splits tasks; it only moves if you explicitly state in your words to "start several agents in parallel, wait for all, and return a summary". Its core value is to move noisy intermediate products off your main desk (remember the Context Window?).
Skill (Agent Skills)
In one sentence: Packs a set of fixed steps into a capability; write it once, and Codex can easily follow it from then on.
Analogy: A recipe card. For a job you repeatedly ask it to do, like "summarize uncommitted changes and flag risks", rather than retyping the command every time, it is better to write it as a recipe card (SKILL.md), specifying the name, description, and steps inside. After that, you can call it by name, or it will automatically match it based on what you say. The "Shortcuts" on mobile phones share this exact flavor.
Hook
In one sentence: An automatic script hung on a certain point in the Codex working lifecycle; once the event occurs, it will inevitably trigger.
Analogy: An automatic sensor light. It doesn't care who you are or where you are going; as long as the event of "someone passing by" occurs, the light will inevitably turn on. Hooks are like this—at moments such as "before calling a tool", "after calling a tool", "after answering", and "at session start", they automatically run the script you specify. The difference between it and AGENTS.md is: the manual is a "request", while a Hook is an "inevitably fulfilled guarantee".
Plugin
In one sentence: Packs several Skills, MCP servers, and integrations into a kit; install them all at once, manage them as a whole, and remove them as a whole.
Analogy: A "furnished model room" in home decoration. Buying individual items means you have to find item numbers, match sizes, and assemble them yourself one by one; packing them into a kit gets you a model room with a single order. For personal use in a single workflow, writing a Skill is sufficient; only when you need to reuse across projects, share with a team, or release unified versions is it worth packing into a plugin.
| Term | Distinguish in One Sentence | When Do You Touch It |
|---|---|---|
| MCP | The unified interface for connecting external tools | When you want it to connect to databases / designs / browsers |
| Subagent | Works on specific tasks in parallel, returns summary | When one thing needs to be reviewed from multiple angles at the same time |
| Skill | Packs a fixed set of steps into a single move | When you repeatedly want it to do the exact same workflow |
| Hook | A script automatically triggered at specific moments | When you want to force "automatically running something every single time" |
| Plugin | Packs a bunch of capabilities into a kit for one-click installation | When you need team sharing and unified management of an entire set of configurations |
💡 Summary in one sentence: MCP connects tools, Subagents split tasks, Skills pack processes, Hooks lock moments, and Plugins install complete sets—five terms; remember "what problem each solves" and you won't get confused.
04 Model-Related: Whom to Send to Work
This last group is about "which model is helping you behind the scenes the moment you hit Enter". Model names change with versions; what is discussed here are positioning and concepts, and what specific models exist should always be checked on your local /model panel.
gpt-5.5 (Flagship, Default)
In one sentence: The currently recommended flagship model, the most powerful and also the most expensive; it is used by default if not set.
What it means in Codex: For complex programming, cross-module refactoring, stubborn bugs, and research-oriented workflows, sending it is always correct. In most cases, this is enough, and it is what you get if you have never set it.
gpt-5.4-mini (Lightweight, Fast and Cost-Effective)
In one sentence: A lightweight model that runs fast and costs less, suitable for numerous and simple tasks, and also commonly used for subagents.
What it means in Codex: For "grunt work" like fixing minor bugs, adjusting formats, adding comments, and cleaning in batches, sending it saves more money and time than sending the flagship model.
gpt-5.4 (Official Version, distinct from mini)
In one sentence: The official model positioned between the flagship and mini; it is still in use, not phased out, and forms a group with gpt-5.4-mini—do not confuse the two.
What it means in Codex: "The same name but without mini"—it is more powerful than the mini, but saves more money and time than the gpt-5.5 flagship; you can consider it when balancing quality and cost. gpt-5.4-mini is its lightweight tier, and the two are not the same model.
gpt-5.3-codex-spark (Instant, Research Preview)
In one sentence: An instant model optimized for "returning replies in seconds", suitable for high-frequency rapid-fire iterations.
What it means in Codex: It is a Research Preview and is currently only open to ChatGPT Pro; it is normal if you don't see it, it doesn't mean you installed it wrong. It is only needed for live pair programming where you ask a question and it answers in seconds.
Research Preview
In one sentence: An "early-access version" released by the officials for a small scope of users to try first; functions may change at any time, and the scope is often restricted.
What it means in Codex: Things marked as "Research Preview" like gpt-5.3-codex-spark and Chronicle have one thing in common—they might only be open to a certain plan / platform, and can disappear at any time with a version update. When you see these words, treat it as a "trial feature; don't use it for production".
Deprecated Models
In one sentence: Old models that the officials have marked as phased out and no longer recommended; do not write them into your configurations anymore.
What it means in Codex: gpt-5.2 and gpt-5.3-codex under the ChatGPT login method have been officially marked as deprecated. If your scripts, config.toml, or codex exec --model still contain them, switch to the latest ones as soon as possible. I tripped over this myself last month—an automation script I wrote half a year ago had the old model name hardcoded, and when it ran, it directly reported that the model was unavailable; it took me a long time to dig through and remember it was this issue.
| Model | Positioning | Best Suited For |
|---|---|---|
gpt-5.5 | Flagship, Default | Complex programming, refactoring, stubborn bugs, research |
gpt-5.4 | Official version (middle tier) | Balancing quality and cost |
gpt-5.4-mini | Lightweight, fast and cost-effective | Simple batch jobs, use for subagents |
gpt-5.3-codex-spark | Instant (Research Preview) | High-frequency real-time iterations, seeking sub-second responses |
gpt-5.2 / gpt-5.3-codex | Deprecated | Do not use anymore, switch to the latest |
💡 Summary in one sentence: The flagship
gpt-5.5tackles tough jobs,gpt-5.4is the middle tier,gpt-5.4-miniruns fast and saves cost, andgpt-5.3-codex-sparkseeks sub-second responses; "Research Preview" = trial version, and do not write the two deprecated names into configurations anymore.
05 How to Use This Dictionary Well
A dictionary is just a decoration if left unused. Here are three methods I have personally tested and found effective:
First, when you get stuck reading other articles, come back here to search for the word, and leave after reading. Don't struggle endlessly with terminology; this article is meant for you to interrupt at any time and look up—this is exactly the difference between it and other articles: other articles are read from start to finish, while this one is used with Ctrl+F.
Second, memorize the "most easily confused pairs" separately. Here are the pairs I tripped over initially, listed for you to cross-check:
| Easily Confused Pair | How to Distinguish |
|---|---|
| Sandbox vs Approval | Sandbox controls "whether it can", and Approval controls "whether it asks" |
| Reasoning Effort vs Model | Effort is "how long to think", and Model is "whom to send" |
AGENTS.md vs Memory | The manual is a rule that must take effect, while memory is a probabilistic recollection |
| Skill vs Plugin | Skill is a single move, while Plugin is a kit packing multiple moves |
| Subagent vs Hook | A Subagent is only split when you ask for it, while a Hook is inevitably triggered at a specific moment |
Third, the fastest way to memorize is to run a hands-on experiment yourself. Take the concept you forget most often and run its hands-on section in the corresponding chapter—for example, if you don't feel anything about the Sandbox, go back to [02 Core Concepts] and run that little experiment where "creating a file in read-only mode is blocked". I have introduced a few friends who knew absolutely nothing about the command line to Codex, and among those who personally ran the Sandbox block, not a single one asked me again 'why does it refuse to modify files'—seeing it once with your own eyes is worth ten explanations.
💡 Summary in one sentence: This dictionary is for "checking at any time"—search for the word when stuck, memorize the easily confused pairs separately, and go back to run a hands-on experiment for the concept you are least familiar with.
Summary
This article compiles the terminology of the entire book into a portable dictionary, locked down in four groups:
- Basic Concepts: Agent, Agentic loop, Context Window, token—the foundation of all concepts.
- Codex-Specific:
AGENTS.md,codex exec, Sandbox, Approval, Reasoning Effort,service_tier, Chronicle—the unique words of this tool, and also the source of "sometimes working, sometimes not". - Extension Capabilities: MCP, Subagent, Skill, Hook, Plugin—the five-piece suite each solves a single problem; remember "what it is used for" so you won't get confused.
- Model-Related: The positioning of the
gpt-5.5family, what Research Preview is, and which two have been deprecated.
You should now be able to: know which group to look under when you see a term popping up in any other article; distinguish the most easily confused pairs at a glance; and return to the corresponding chapter to run a hands-on experiment when encountering a concept you don't feel familiar with.
Ultimately, terminology is never meant to be engraved; it is engraved into your muscle memory through usage. The role of this dictionary is to give you a safety net to check at any time before it is engraved.
In the next article [39 Enterprise Management and Governance], we will pull the camera back from "how one person uses Codex" to "how a company manages Codex": how permissions are issued in a unified way, how compliance is backed up, and how dozens or hundreds of people using the same tool can avoid chaos. Leave a small thought—looking back at the Sandbox and Approval in this article, when only you are using it, they are "seat belts you set for yourself"; when a team of dozens of people share it, who should buckle this seat belt, and can people unbuckle it at will? This is exactly the problem to be solved in the next article.