On October 8, OpenAI attached Ultrafast mode to GPT-6.1 Sol. It is not a new model, but a faster way to serve the same model. Set service_tier to ultrafast in the Responses API. The rollout covers the API, Codex, and ChatGPT Work together.

Pricing runs 6x Standard. On short context, $12 per million input tokens and $60 per million output tokens. Standard sits at $2 and $10, so exactly 6x. The official line is that it can fit realtime services where fast replies matter.

Standard, Fast, and Ultrafast price and speed tiers with measurement items and WebSocket guidance

That is the whole post in one picture. Same model, different tier, different price. The decision rule is measurement, not feel.

Setup is one line: service_tier ultrafast

What changes is the serving tier, not the model ID. Keep gpt-6.1-sol and pick the tier per request. GPT-6 Astra uses Ultrafast too.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    input="Explain empty-value handling in a Python form.",
    service_tier="ultrafast",
)

print(response.output_text)
print(response.service_tier)
print(response.usage)

Always check the returned service_tier. Project defaults, regions, and limits can land the request on another tier, and billing follows the tier actually served. Pinning to an unsupported region drops to Standard.

For agent-like work with frequent tool calls, a persistent WebSocket connection is recommended. Recreating the connection every turn adds network overhead that eats part of the inference gain. HTTP works for smoke tests, then measure WebSocket on call-heavy flows.

The price table: what 6x exactly means

Official short-context figures, meaning up to 272K input tokens:

Model Standard input / output Fast input / output Ultrafast input / output
GPT-6.1 Sol $2 / $10 $4 / $20 $12 / $60
GPT-6 Astra $10 / $50 $20 / $100 $60 / $300

Fast is 2x Standard, Ultrafast is 6x. Cached input and cache writes carry their own tier rates. Long context and regional processing add multipliers. Pinned regions run Sol on US and EU, Astra on US only. Global processing covers both.

Limits are separate too. Ultrafast does not share rate limits with Standard or Fast. Default tokens per minute for Sol run Build 1M, Launch 4M, Grow 40M. Astra is smaller at Build 500K, Launch 1M, Grow 5M. Check organization limits before raising traffic, and talk to the account team for more.

One Codex and ChatGPT Work note. API billing and subscription entitlements follow different rules. The launch mentions up to 8x faster token generation versus Standard in Codex. Do not put subscription feel and API bills in one table.

When Ultrafast fits: only when realtime matters

Even with identical model quality, a market for paying extra for speed is forming. The question shifts from which model to when a fast tier earns its keep.

Suspect Ultrafast first:
- Realtime UI and voice where late first tokens lose users
- Coding loops and live support with many short round trips
- One reply a person is actively waiting for

Standard fits:
- Batch, offline, and bulk jobs
- Long agent runs with retries and checks
- Output-heavy jobs where 6x multiplies directly

Look at time and cost per task, not speed per token. Long outputs carry the full 6x. Measure time to first token with streaming, alongside end-to-end time. A non-streaming sample only times completion and misses first response.

CodeBridge Mini Lab: same request across three tiers

The briefing's action, directly: run Standard and Ultrafast on identical requests.

1. Same prompt, effort, tools, and data across default, fast, and ultrafast, at least twice each
2. Record: time to first token, model duration, tool duration, end to end
3. Quality: accepted or not, rework minutes, failures and manual fixes
4. Aggregate: p50 and p95, cost per completed task
5. Confirm: actual tier and usage in the response, plus project default routing

A successful HTTP response is not an accepted outcome. One row per task with tier, tokens, timing, acceptance, and rework shows whether Ultrafast earns its price. Test peak traffic and retry handling too.

Pair this with the model-speed guide on splitting fast first reactions from heavy analysis. Cost yardsticks continue in the cost-per-task post and the Sol versus Astra post.

Conclusion: it cuts waiting, not work

One line to keep:

Tiers differ even on the same model. A fast tier buys less waiting, not fewer tokens.

Ultrafast is a realtime option, not universal acceleration. Find one wait worth 6x, then run the same request across three tiers. Time to first response, p95, and cost per completion will tell you which to pick.

Further reading

References

Go deeper with a course

Splitting fast first reactions from heavy analysis gets easier once agent execution structure is clear. If you need practice breaking work apart and verifying it, the five-stage path connects directly to this post's speed pattern.