OpenAI Ultrafast in Codex and the API: plans, setup, cost

By Rogier Muller09.29.26
OpenAI Ultrafast in Codex and the API: plans, setup, cost

OpenAI Ultrafast is a premium speed tier that OpenAI launched at DevDay on 29 September 2026. GPT-6 Astra Ultrafast generates tokens up to 8x faster in Codex, about 300 tokens per second, and up to 6x faster in the API (Ultrafast mode guide). It is available for GPT-6 Astra and GPT-6.1 Sol. The API changelog added Ultrafast for GPT-6.1 Sol on 8 October 2026.

Which plans get Codex Ultrafast?

Ultrafast in Codex and ChatGPT Work is limited to the top Pro tier and to usage-billed Enterprise and Edu plans. The Codex speed docs and the Pro tiers help article give this picture:

Plan Codex Ultrafast
Pro 100 ($100 a month) Not included
Pro 200 ($200 a month) Not included
Pro 500 ($500 a month) Included; uses included usage first, then credits
Enterprise on credit-based or USD usage-based agreements Eligible; off by default until a workspace owner enables it
Enterprise on legacy rate-limit plans Not supported
Edu plans that use credits Eligible
Other self-serve plans Not available at launch, even with purchased credits
OpenAI API GPT-6 Astra and GPT-6.1 Sol for all API users, subject to rate limits

Buying credits on Pro 100 or Pro 200 does not give you Ultrafast. In Codex, GPT-6 Astra Ultrafast supports inference residency in the United States only. GPT-6.1 Sol Ultrafast also supports Europe (EEA and Switzerland). In the API, Sol Ultrafast supports US and EU data residency and global processing, and Astra Ultrafast supports US data residency and global processing only. The plan rows follow the Codex speed page checked on 8 November 2026.

Rolling this out in your team?

We train engineering teams on their own codebase in two days. Codex setup, shared rules and review included.

How to turn on Ultrafast in Codex

On Pro 500, Ultrafast is selectable in the model picker. On Enterprise, a workspace owner first enables it for selected users or the whole workspace through workspace permissions. Existing per-user spend controls apply to Ultrafast usage.

The Codex docs are specific about Fast mode, the cheaper speed tier, but not about an Ultrafast switch in the CLI. Fast mode toggles with /fast, and you can make it the default in config.toml:

service_tier = "fast"

[features]
fast_mode = true

At the time of writing, the docs do not list a CLI command or config value for Ultrafast. Use the model picker, and check the speed page before you script it.

If you run Codex with an API key instead of ChatGPT sign-in, Codex uses API token pricing and the ChatGPT credit multipliers do not apply.

Ultrafast mode API setup

In the API, set model to gpt-6-astra or gpt-6.1-sol and service_tier to ultrafast. This is the plain HTTP request from OpenAI's guide, using Astra:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Explain why the sky is blue in one sentence.",
    "service_tier": "ultrafast"
  }'

For agent loops, OpenAI strongly recommends a persistent WebSocket connection. Without it, network overhead between tool calls eats into the speed gain. The Python version from the guide keeps one connection open and chains turns with previous_response_id:

from openai import OpenAI

client = OpenAI()
previous_response_id: str | None = None
prompts = [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
]

with client.responses.connect() as connection:
    for prompt in prompts:
        connection.response.create(
            model="gpt-6-astra",
            service_tier="ultrafast",
            previous_response_id=previous_response_id,
            input=prompt,
        )
        for event in connection:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "response.completed":
                previous_response_id = event.response.id
                print()
                break
            elif event.type in {"response.failed", "response.incomplete", "error"}:
                raise RuntimeError(event.to_json())
        else:
            raise RuntimeError("Connection closed before the response finished.")

Default Ultrafast rate limits use the Build, Launch, and Grow usage tiers. OpenAI simplified the previous five tiers to these three on 6 October 2026. GPT-6 Astra is 500,000 tokens per minute on Build, 1,000,000 on Launch, and 5,000,000 on Grow. GPT-6.1 Sol is 1,000,000, 4,000,000, and 40,000,000 on those same tiers. Teams with an OpenAI account team can ask for higher limits.

What does Ultrafast cost?

The API pricing page lists these rates per 1M tokens. Short context means up to 272K input tokens. Long context means more than 272K. The cache-write column is the 30-minute write on short-context rows, and the single cache-write price the page lists for long context. Updated 8 November 2026 from the OpenAI pricing page.

Model and tier Input Cached input Cache writes Output
Astra standard, short context $10 $1 $12.50 $50
Astra Ultrafast, short context $60 $6 $75 $300
Astra Ultrafast, long context $120 $12 $150 $450
Sol standard, short context $2 $0.10 $2.50 $10
Sol Ultrafast, short context $12 $0.60 $15 $60
Sol Ultrafast, long context $24 $1.20 $30 $90

The 12-hour cache write at short context is $25 for Astra standard, $150 for Astra Ultrafast, $5 for Sol standard, and $30 for Sol Ultrafast. Regional processing endpoints add 10% for models released on or after 5 March 2026. Astra Ultrafast input and output remain six times Astra standard at short context. Sol Ultrafast input and output are six times Sol standard, and 1.2 times Astra standard, at short context. The models are separate choices.

Take an agent loop of 30 requests. Each one sends the same 40K-token prefix plus 5K new tokens, and gets 1.5K tokens back. The first request writes the prefix to the cache and the next 29 read it. On standard Astra that loop costs about $5.41. On Ultrafast it costs about $32.46.

In Codex, Ultrafast uses included subscription limits at 8x the standard rate. Purchased credits and Enterprise pay-as-you-go usage are billed at 6x. OpenAI notes these multipliers describe billing only. The 8x speed figure measures token generation alone, so tool calls and test runs take as long as before.

A Codex workflow where the speed pays off

Ultrafast earns its price when you sit and wait on each turn. A tight interactive loop on a failing test is the clearest case. You read the diff, ask for a change, and wait again. Faster generation shortens every wait in that loop.

It is poor value for work you do not watch. A Codex cloud task that runs while you are in a meeting gains little from faster tokens, and you pay the multiplier anyway.

Speed also raises the number of diffs you have to read per hour. Keep your review bar fixed. Put the test command and the evidence you expect in the repo's AGENTS.md, so a faster turn still ends with a test result as well as a patch. Our Delegate, Review, Own methodology covers that review step.

Pick one interactive bug-fix session this week, run it once on standard Astra and once on Ultrafast, and compare wall-clock time with the usage it consumed.

Further reading

Train your team on Codex

Two days on your team's own repository, onsite or remote, with a written proposal before you commit.

Book a call

Prefer to measure first? Take the free team check.