Codex Fast Mode (/fast) in 2026: Supported Models, Speed, Cost and Ultrafast

Quick Answer

Codex Fast mode trades usage for speed. Toggle it with /fast in the Codex CLI, or make it the default with service_tier = "fast" plus [features].fast_mode = true in ~/.codex/config.toml; it works in the ChatGPT desktop app, the Codex CLI and the IDE extension when you sign in with ChatGPT. According to OpenAI's Codex speed docs, it supports GPT-6.1 Sol, GPT-6.1 Terra, GPT-6 Astra, GPT-6 Sol and GPT-6 Luna where available (for GPT-5.6 the speedup is 1.5x), and it uses included subscription limits at 2.5x the Standard rate; purchased credits and Enterprise pay-as-you-go usage are billed at 2x. A separate Ultrafast mode for GPT-6 Astra and GPT-6.1 Sol generates tokens up to 8x faster than Astra in Standard mode, on Pro $500 and eligible Enterprise and Edu plans, at 8x included limits (6x for credits). The rest of this guide was written in August 2026 for the GPT-5.x models; the mechanism is the same.

No card at all? You can also top up with USDT, USDC or ETH: click Pay with crypto in the top-up dialog and send it from Binance, OKX or any wallet. The minimum is $5 and no browser extension is needed. Step by step: Pay for Claude and GPT APIs with crypto (USDT).

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-sol"
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. Under the hood, 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. Through TeamoRouter, requests that ran in Fast mode show a "Fast" hint in your billing history.

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. If you've already run out, see Codex "You've hit your usage limit": what it means and how to keep coding.

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. For the GPT-6 Sol model ID, its config and whether Fast mode applies to it, see GPT-6 Sol API pricing and Codex CLI setup.

First, point Codex at TeamoRouter in ~/.codex/config.toml:

model_provider = "teamorouter"
model = "gpt-5.6-sol"

[model_providers.teamorouter]
name = "TeamoRouter"
base_url = "https://api.teamorouter.ai/v1"
env_key = "OPENAI_API_KEY"
wire_api = "responses"

and export your TeamoRouter key:

export OPENAI_API_KEY="sk-teamo-xxxxxx"

Then enable Fast mode inside the Codex session:

/fast

Or persist it by adding this line at the top of ~/.codex/config.toml (above the [model_providers.teamorouter] table):

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.ai/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?

At the time of writing (August 2026): GPT-5.6, GPT-5.5, and GPT-5.4. The list has changed since the GPT-6 series launched, so check your current Codex version. 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. You can also pay with USDT: click Pay with crypto in the top-up dialog and pay with USDT, USDC or ETH from Binance, OKX or any exchange app — no browser wallet needed, and the checkout shows which networks your amount supports (BEP20 works from $5). See how to pay with USDT.

1. Sign up at TeamoRouter
2. Generate an API key from the dashboard
3. Point Codex at https://api.teamorouter.ai/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.