Codex Fast Mode: Everything Developers Need to Know in 2026 | TeamoRouter

Quick Answer

Codex Fast mode is a speed tier for the Codex CLI, desktop app, and IDE extension that trades extra credits for lower latency. It boosts the response speed of supported GPT models by about 1.5x, while consuming 2x to 2.5x the credits of Standard mode. You toggle it with the built-in /fast command, persist it in ~/.codex/config.toml under service_tier = "fast", and it only applies to GPT-5.6, GPT-5.5, and GPT-5.4. Under the hood, Fast mode is the ChatGPT-credits incarnation of the same service_tier mechanism that OpenAI's API calls "Fast mode" (formerly "Priority processing") — which is exactly what a router like TeamoRouter can pass through with a one-line config.

What Is Codex Fast Mode?

Codex is OpenAI's AI coding agent that runs in the terminal, in a desktop app, and inside IDEs. When you run a task, the model has to generate tokens, and that generation speed — measured in tokens per second — directly affects how long you stare at a blinking cursor.

Fast mode is a service tier, not a different model. Instead of switching to a smaller or less capable model, you keep the same intelligence and ask the backend to schedule your request at a higher priority, which produces faster and more consistent token generation. The model's answers are not "smarter" and not "dumber" — they arrive faster.

The three supported models as of August 2026 are:

The multiplier matters: GPT-5.6 and GPT-5.5 burn 2.5x credits in Fast mode, while GPT-5.4 burns a comparatively gentler 2x. If a model does not support Fast mode, the CLI simply omits the tier and falls back to Standard — there is no crash and no silent surcharge.

Fast Mode vs Codex-Spark vs API Priority: Don't Confuse Them

The 2026 Codex landscape has three related but distinct concepts that get mixed up constantly:

1. Codex Fast mode (ChatGPT credits) — the /fast toggle you use while signed in with ChatGPT. It speeds up GPT-5.6/5.5/5.4 at 2-2.5x credit cost. This is what this article covers.

2. Codex-Spark — a separate, fast, less-capable Codex model optimized for near-instant iteration, offered to Pro subscribers. It is its own model choice with its own usage limits, not a speed tier on top of GPT-5.6.

3. API Fast / Priority processing (token billing) — when you call OpenAI's API (or an OpenAI-compatible gateway) with service_tier: "fast" (legacy value "priority"), you pay per token at 2x the standard token rate. API-key users get token pricing instead of ChatGPT credit pricing. On July 30, 2026, OpenAI renamed "Priority processing" to "Fast mode" across the API, so the old priority value still works and behaves identically.

If you use Codex with an API key rather than a ChatGPT subscription, the /fast command and the credit multiplier do not apply the same way — you are billed by tokens, and the speed tier is controlled by service_tier. That distinction is the single most common source of confusion, so remember it before you start toggling flags.

How to Enable Fast Mode

The /fast Slash Command

Inside the Codex CLI (and the desktop app and IDE extension, when signed in with ChatGPT), Fast mode is a session toggle:

# In an interactive Codex session:
/fast

Type it once to enable, type it again to disable. There is no separate on/off syntax in the current stable CLI — /fast is a plain toggle. Some community builds and wrappers expose /fast on, /fast off, and /fast status, but the official client keeps it simple.

Permanent Config in config.toml

If you want every request in a project to use Fast mode without typing /fast every session, add a service_tier line to your Codex config:

# ~/.codex/config.toml
model = "gpt-5.6"
service_tier = "fast"

[features]
fast_mode = true

The service_tier = "fast" key is what actually routes the request to the fast tier. The [features].fast_mode = true gate enables the feature and is stable by default. When a model does not expose a Fast tier, the CLI silently omits the tier — a safe fallback rather than an error.

Verifying It's Active

Run /fast and then send a prompt. In verbose mode you can inspect the request payload; Fast mode sets the wire value to service_tier: "priority" (the legacy wire name that the backend still accepts), while Standard mode sends no override at all. If you see the tier in the payload, Fast mode is on.

What It Actually Costs

Fast mode pricing is where most developers get surprised, so let's be precise.

In ChatGPT Credits

"Credits" are the consumption unit of ChatGPT subscriptions (Pro, Plus, etc.). A 2.5x multiplier means a task that would have consumed 1,000 credits in Standard mode consumes 2,500 in Fast mode. For heavy agentic sessions that run hundreds of turns, this adds up quickly — which is exactly why the official guidance is to reserve Fast mode for interactive, latency-sensitive work.

In API Tokens (OpenAI or a Gateway)

When you use the API instead of ChatGPT credits, Fast mode is billed per token at 2x the Standard list price. For GPT-5.6 Sol:

This is the same price structure that OpenAI's API calls "Fast mode" and that TeamoRouter passes through transparently.

The TeamoRouter Angle: Your Discount Carries Over

Here is the important part for anyone using a gateway: when you route Codex through TeamoRouter, Fast mode is billed at 2x list price, and your account discount still applies on top of that. From TeamoRouter's billing docs:

In Fast mode, the model list price is 2x the standard-mode price, while your existing account discount remains unchanged.

Concretely, if standard gpt-5.6-sol output lists at $30 and your account has a discount, the Fast-mode list price becomes $60 and the same discount is applied to that $60 — not to the discounted standard price. The billing UI marks Fast requests with a "Fast" hint so you can spot them in your transaction history.

When Should You Use Fast Mode?

Use It For

• Interactive, latency-sensitive coding. Live pair-programming, debugging where you are waiting on a response, and REPL-style exploration benefit most. A 1.5x speedup that removes a few seconds per turn compounds across a long session.
• Agent steps that block your attention. When Codex is doing sequential edits and you are reading each diff, lower time-to-first-token keeps you in flow.
• Demoing and pair sessions. When someone is watching the screen, fast responses look dramatically better even if the total tokens are identical.

Skip It For

• Batch jobs and background agents. If you kick off a refactor and walk away, the 2-2.5x credit premium buys you nothing.
• Long-context requests. Fast mode excludes long-context workloads in several configurations; the CLI falls back to Standard rather than erroring.
• Budget-constrained accounts. At 2.5x for GPT-5.6, a heavy all-day Fast session can consume your credit balance in hours. Standard mode is the default for a reason.

A reasonable default policy: keep Standard as the global default in config.toml, and toggle /fast on only for the specific interactive tasks where latency is the bottleneck.

Fast Mode Through TeamoRouter: Configuration

If you run Codex through TeamoRouter (which gives you Alipay/WeChat Pay billing, one API key across OpenAI/Anthropic/Gemini models, and direct connectivity from restrictive networks), enabling Fast mode is a two-minute job.

First, point Codex at TeamoRouter:

export OPENAI_BASE_URL="https://api.teamorouter.com/v1"
export OPENAI_API_KEY="sk-teamo-xxxxxx"

Then enable Fast mode inside the Codex session:

/fast

Or persist it in ~/.codex/config.toml:

model = "gpt-5.6"
base_url = "https://api.teamorouter.com/v1"
service_tier = "fast"

From the gateway side, you can also send service_tier: "fast" directly in an OpenAI-compatible Chat Completions or Responses API call:

from openai import OpenAI

client = OpenAI(
    api_key="sk-teamo-xxxxxx",
    base_url="https://api.teamorouter.com/v1",
)

resp = client.responses.create(
    model="gpt-5.6-sol",
    input="Refactor this function to reduce its cyclomatic complexity.",
    service_tier="fast",  # Fast mode (formerly "priority")
)
print(resp.output_text)

The legacy value still works:

"service_tier": "priority"

Both fast and priority apply to every GPT-series model that supports the tier, and gpt-5.6-sol runs up to 2.5x faster than Standard with Fast enabled. Note that for GPT-5.6 and earlier models, the response object's service_tier field may still echo "priority" — that is expected and harmless.

The Bottom Line

Codex Fast mode is a speed option, not a capability upgrade. For interactive, latency-sensitive work it is genuinely useful; for batch and background work it is a pure expense. The three things worth remembering:

1. /fast is a toggle — enable it per session, or persist service_tier = "fast" in config.toml.
2. It costs 2-2.5x — 2.5x credits for GPT-5.6/5.5, 2x for GPT-5.4; in API mode, 2x the token list price.
3. Your gateway discount still applies — through TeamoRouter, Fast mode is billed at 2x list with your existing account discount preserved, and a "Fast" hint marks those requests in billing.

If you are already paying for latency with default settings, Fast mode is the cheapest way to buy responsiveness without changing models. If you are not latency-bound, leave it off and let Standard mode do the work.

FAQ

Does Fast mode make Codex smarter?

No. Fast mode changes only the speed and consistency of token generation, not the model or its intelligence. The same model answers the same question either way.

What models support Codex Fast mode?

GPT-5.6, GPT-5.5, and GPT-5.4. Unsupported models silently fall back to Standard — there is no error and no hidden charge.

Is Fast mode the same as Codex-Spark?

No. Codex-Spark is a separate, lighter model optimized for fast iteration, with its own usage limits. Fast mode speeds up an existing supported model at a higher credit cost. They are different features and can be combined.

Why does Fast mode use more balance?

Because it is billed at 2x the standard model list price, and in ChatGPT-credit mode at 2-2.5x the credit consumption. Your account discount (if any) still applies to the 2x list price, which is why the ratio is not exactly 2x after discount.

I use an API key, not ChatGPT — does /fast work the same?

Not exactly. With API-key billing you are charged per token, so the ChatGPT credit multiplier does not apply. You control the speed tier with service_tier — either through /fast if your client supports it, or directly in the request payload. Through TeamoRouter, set service_tier: "fast" and the 2x list price with your discount is billed transparently.

How do I turn Fast mode off?

Type /fast again to toggle it off for the session, or remove the service_tier = "fast" line from ~/.codex/config.toml. Check your billing UI for the "Fast" hint on requests to confirm which requests ran in Fast mode.

Get Started with Codex on TeamoRouter

Fast mode is a small lever — but it only helps if your Codex backend is reachable and priced sanely. TeamoRouter gives you one API key for Codex, Claude Code, and Gemini CLI, with Alipay/WeChat Pay top-ups, floating-rate discounts, and direct access from restrictive networks.

1. Sign up at TeamoRouter
2. Generate an API key from the dashboard
3. Point Codex at https://api.teamorouter.com/v1 and toggle /fast when you need speed

Get Your Fast Codex Setup →

Access Codex, Claude Code, and Gemini CLI stably through TeamoRouter — one key, one base URL, Fast mode included.