Codex Fast vs Medium

Two different knobs on Codex / ChatGPT — one multiplies how fast credits burn, the other multiplies how hard the model thinks (and how many tokens it generates)

← AI · AI Agents · Productivity · Token saver · Codex engineering · ChatGPT Work · Codex apps

Why this page exists

Short version of a real session: I turned on Fast while working in ChatGPT / Codex, watched usage melt, and switched back to Medium because I didn’t need that much latency. The open question was simple — is Fast “just speed,” or is something else driving the burn?

Answer from unpacking it with Grok (web): it’s not just speed. Fast and Medium are independent controls. Mixing them up is why “token usage” feels mysterious when Fast is on.

Route: /codexfast (easy to remember). Same model applies in ChatGPT product UIs. Old path /fastvsmedium 301s here.

One-sentence TL;DR

Fast = higher-priority inference path + a credit/usage multiplier on roughly the same work. Medium = a reasoning-effort level that changes how many (often invisible) reasoning tokens the model actually generates. Leave Fast off to preserve limits unless latency really matters; drop effort for simple tasks to reduce real tokens, not just the billing multiplier.

The two knobs (independent)

	Fast mode (speed / priority)	Medium (and other effort levels)
What it is	Higher-priority inference path (smaller batches / reserved capacity)	Reasoning-effort setting (Instant / low / medium / high / extra-high, etc.)
What changes	Token throughput (how fast tokens arrive) + how hard usage is metered	How long the model “thinks” before the visible answer — more or fewer total tokens
Intelligence for same prompt + effort	Same underlying generation quality for a given effort level	Higher effort → more internal reasoning tokens → usually better hard-task quality, more burn
Why your bar empties	Multiplier on credits (~2–2.5× typical in ChatGPT/Codex Fast)	More actual tokens generated and counted (reasoning + output)
API angle	Premium pay-per-token (often ~2×), higher throughput (reports up to ~2.5× on some models)	Same $/token across efforts; you just buy more tokens when effort is high

Mental model

Fast is like an express lane fee on the same trip. Medium / High effort is like taking a longer route with more thinking steps. You can do express + long route at once — that’s when the meter goes crazy.

Fast mode (speed / priority)

Higher-priority path: meaningfully higher token throughput (order-of-magnitude reports: ~1.5× in ChatGPT/Codex UX, up to ~2.5× in API for some models such as GPT-5.6-class Sol — product numbers move).
For a fixed prompt + fixed reasoning effort, the tokens produced stay in the same ballpark; you’re mainly paying for speed and capacity.
In ChatGPT and Codex, Fast typically burns credits at roughly ~2.5× the standard rate (sometimes ~2× on earlier model generations). Same reply → much heavier hit on weekly / 5-hour / credit buckets.
API Fast is closer to pure pay-per-token at a premium (often ~2×) without the same “weekly message” theater — but the bill still feels like “more tokens” if you only look at spend.

This is the main reason Fast feels like “so much more token usage”: the product is metering the same work at a higher rate, not necessarily writing a novel you didn’t ask for.

Medium (reasoning effort)

Medium sits on the effort ladder: Instant / low / medium / high / extra-high (labels vary by product).

Higher effort → more internal reasoning tokens (often not fully shown in the UI) before the visible answer.
Those reasoning tokens are billed / counted. Hard tasks at medium or high can easily double or more total tokens vs Instant/low for similar-looking final text.
Per-token price usually stays the same across effort levels; you simply generate more of them.
Lower effort favors speed and lower total token count — fine for “rename this file,” bad for “redesign the auth system.”

So when I “switched back to Medium,” that was really: stop paying the Fast multiplier, keep a moderate thinking budget. If the task is simple, dropping below Medium saves real tokens, not just the express-lane fee.

Combinations (what you actually feel)

Setting	Latency	Credit / limit burn	When it makes sense
Fast on + Medium	Faster replies	High — multiplier on whatever Medium generates	Live pair-programming, demos, waiting on a critical unblock
Fast off + Medium	Normal	Normal rate × Medium token volume	Default for most work (where I landed)
Fast off + Low / Instant	Often snappy enough	Lowest real token volume	Typos, renames, simple Q&A, “what does this flag do?”
Fast on + High / X-High	Fast and deep	Brutal — multiplier × large reasoning trace	Rare: production fire, hard bug, deadline demo only
Fast off + High	Slower wall-clock	High token count, standard rate	Architecture, multi-file refactors, security review

Field notes — personal take

What I tried

Ran with Fast while testing. Throughput felt better; the usage bar moved like a stopwatch on 2×. Switched Fast off / stayed on Medium once I realized I didn’t need the express lane for most turns.

What I thought was happening

“Fast must be generating way more tokens.” That’s the natural misread when the product only shows one usage meter.

What’s actually happening

Mostly a billing / priority multiplier for Fast, plus whatever effort level is selected for real reasoning tokens. Two stories, one progress bar.

Default I’ll use

Fast off, Medium on for normal coding and writing. Drop effort for chores. Turn Fast on only when I’m blocked on waiting.

Practical playbook

Preserve limits first? Leave Fast off. You’re paying a multiplier for latency, not free intelligence.
Simple task? Drop reasoning effort (Instant / low). That reduces actual tokens generated — better than only toggling Fast.
Hard task, not urgent? Fast off + high effort. Pay in wall-clock time, not express fees.
Hard task + live collaboration? Fast on only for the stretch where someone is waiting; turn it off when you go heads-down alone.
API / automation? Prefer standard rate + explicit max tokens / effort caps. Fast is a pure money lever — easy to leave on by accident in a script.
Still burning? Effort and Fast aren’t the only sinks — long chats, huge contexts, redoing whole files. See Token Saver (Claude-oriented but the habits transfer).

Quick FAQ

Is Fast a smarter model?

No. Same model family path for a given choice of model + effort; Fast is capacity and metering, not a free upgrade to a better brain.

Does Medium cost more per token?

Usually not. Medium (and higher) cost more because the model emits more tokens, especially reasoning tokens you may barely see.

Why did Fast feel like “more tokens” in the UI?

Credit multipliers and rate limits often display as a single “usage” story. Express-lane work drains the same bucket faster even when raw token counts are similar.

ChatGPT vs Codex — same idea?

Same two-axis mental model: priority/speed path vs reasoning effort. Exact multipliers and labels drift by product and model generation — treat numbers on this page as order-of-magnitude field notes, not a billing contract.

Related on this site

Token Saver — habits that waste tokens regardless of Fast/effort
Codex engineering — how the coding agent is built (loop, tools, safety)
Codex apps — mobile / product surfaces
ChatGPT Work — capabilities tour
2-hour prompting — when deeper reasoning is worth it
Harness tips · CLI for agents

Field notes · August 2026 · Fast = speed + meter · Medium = how hard it thinks