The model dial: matching Codex's brain to the task

Every Codex session makes a decision most people never notice: which brain, thinking how hard. The GPT-5-class family behind Codex spans a range of tiers, each with an adjustable reasoning effort that controls how long the model deliberates before acting. Both are cost levers. Most people leave them wherever the defaults landed, or worse, pin everything to maximum and call it rigor.

Two axes, one dial

Axis one is model tier: smaller variants for cheap throughput, the frontier tier for hard reasoning. Axis two is reasoning effort, low to high, which sets how many deliberation tokens the model burns per step. That second axis compounds: an agent loop runs dozens of steps per task, so a per-step multiplier becomes a per-session multiple. As of this writing you can flip both mid-session with the CLI's /model picker and pin defaults in your Codex config:

# ~/.codex/config.toml
model_reasoning_effort = "medium"

Effort is the axis worth learning first. On most tasks it moves cost and latency far more than it moves quality.

Match the effort to the task shape

• Low: mechanical work. Renames, boilerplate, applying an established pattern across files, writing the tenth test that looks like the first nine. The task is fully specified; extra deliberation buys latency, not correctness.
• Medium: the daily default. Ordinary feature work, standard refactors, test triage — mild ambiguity that resolves without deep thought.
• High: genuinely gnarly. Race conditions, cross-module debugging, a memory leak with three plausible causes, architectural rework. Here deliberation is the product: the model needs to hold a theory, test it, and revise. Why thinking longer helps on exactly this shape is the subject of reasoning models explained.

Reasoning effort is a price dial, and pinning it to maximum is superstition wearing an engineering costume.

The max-everything mistake

Running high effort on everything fails three ways at once. Cost: you pay a large multiple on session spend for identical output on routine work. Latency: every turn slows down enough that you stop steering, and an expensive loop running unsupervised is the worst of both worlds. Quality: on fully specified tasks, extra thinking often means the model second-guesses a plan that was already correct and rewrites working code for sport.

The mirror-image mistake is just as real. A task that looks mechanical but isn't (the simple rename that is secretly an API contract change) makes a low-effort run thrash: retries, contradictory edits, tokens burned on flailing. When a cheap run starts looping, stop it and escalate. One high-effort pass costs less than five low-effort ones plus your cleanup afterwards.

The deeper point: with Codex, you are the router. Nothing in the stack picks effort for you as of this writing. This is the manual version of the job an autorouter does in larger systems, and it runs on the same economics that drive the 99 percent cost architecture: send the bulk of the work to cheap execution and reserve the expensive brain for the minority that earns it. My working rule: default to medium; drop to low when the output is mechanical and machine-verifiable; escalate to high on evidence, meaning a failed cheap attempt or a task you would route to your most senior engineer. Then audit actual spend monthly. Your intuition about which bucket dominates your bill will be wrong, and the direction it is wrong in will tell you something useful about your backlog.