OpenAI Agents API Ultrafast Mode: Reduce Latency

To enable Ultrafast mode in the OpenAI Agents API, set agent.service_tier to "ultrafast" alongside a supported reasoning model such as gpt-6.1-sol or gpt-6-astra. This routing profile optimizes token delivery to reduce the time between generated tokens during agent runs.

OpenAI introduced Ultrafast mode for the Agents API on October 16, 2026, as documented in the OpenAI platform changelog. When your agent runs interactive turn-by-turn tasks, generating code, or handling tool orchestration, this mode prioritizes generation speed over standard tier queues.

How Ultrafast mode works in the Agents API#

When an agent executes an instruction, latency comes from two phases: time to first token (prompt evaluation and reasoning) and inter-token latency (the time elapsed between each generated output token). In agents that execute tool calls, generate code snippets, or compose lengthy structured responses, inter-token latency often forms the largest part of the user's perceived wait time.

Ultrafast mode directly targets inter-token output latency. Setting agent.service_tier to "ultrafast" routes inference through dedicated high-throughput compute clusters. While standard requests queue behind regular traffic tiers (Build, Launch, or Grow), Ultrafast requests bypass those queues to deliver faster token streaming.

If you already run standard endpoints via our guide to the OpenAI API in Python, switching to the Agents API requires instantiating an agent resource rather than sending stateless completions.

Supported models and parameters#

According to the OpenAI models catalog and the OpenAI platform changelog, Ultrafast mode supports the primary GPT-6 series models:

• gpt-6.1-sol: Balanced for complex coding, professional tasks, and tool calls.
• gpt-6-astra: Flagship model for high-effort reasoning, complex multi-turn workflows, and computer use.

Models such as gpt-6-luna support standard and fast tiers, but the official docs do not list Ultrafast mode for Luna as of October 2026.

Here is how the configuration parameters map inside an agent definition:

{
  "model": "gpt-6.1-sol",
  "service_tier": "ultrafast",
  "instructions": "You are a technical support agent. Use provided tools to query order status."
}

Configuring agent.service_tier with the Agents API#

You can set service_tier when creating an agent through the v1/agents endpoint. Here is an example request using curl against the REST API:

curl https://api.openai.com/v1/agents \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "code-reviewer",
    "model": "gpt-6.1-sol",
    "service_tier": "ultrafast",
    "instructions": "Analyze pull requests and inspect code syntax errors."
  }'

When updating an existing agent, pass service_tier in a PATCH or POST update payload to alter the inference tier without modifying instructions or tools:

curl https://api.openai.com/v1/agents/agent_abc123 \
  -X POST \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "service_tier": "ultrafast"
  }'

If your agent connects to external context servers via tools, see our walkthrough on how to build an MCP server in Python to ensure your local or remote tools respond fast enough to keep pace with Ultrafast output generation.

Ultrafast mode pricing and cost calculations#

Ultrafast compute carries a significant pricing premium over Standard, Fast, and Batch rates. Before routing all production traffic through Ultrafast mode, calculate the expected token cost.

According to the OpenAI pricing page, standard and Ultrafast token rates per 1 million tokens (MTok) break down as follows:

For gpt-6.1-sol, Ultrafast output tokens are $60.00 per million compared to $10.00 on standard. For gpt-6-astra, Ultrafast output tokens cost $300.00 per million compared to $50.00 on standard. In both cases, the multiplier is 6x the standard rate.

Here is a simple Python script to estimate cost differences across token volumes:

def calculate_run_cost(model: str, tier: str, input_tokens: int, output_tokens: int) -> float:
    rates = {
        ("gpt-6.1-sol", "standard"): (2.00, 10.00),
        ("gpt-6.1-sol", "ultrafast"): (12.00, 60.00),
        ("gpt-6-astra", "standard"): (10.00, 50.00),
        ("gpt-6-astra", "ultrafast"): (60.00, 300.00),
    }

    in_rate, out_rate = rates[(model, tier)]
    cost = (input_tokens / 1_000_000 * in_rate) + (output_tokens / 1_000_000 * out_rate)
    return round(cost, 4)

standard_cost = calculate_run_cost("gpt-6.1-sol", "standard", 50_000, 10_000)
ultrafast_cost = calculate_run_cost("gpt-6.1-sol", "ultrafast", 50_000, 10_000)

print(f"Standard cost: ${standard_cost}")
print(f"Ultrafast cost: ${ultrafast_cost}")
print(f"Multiplier: {round(ultrafast_cost / standard_cost, 1)}x")

Regional data residency gotchas#

Before deploying Ultrafast agents in production, review regional processing limitations. According to the OpenAI platform changelog:

1. Data residency restrictions with Astra: For gpt-6-astra, Ultrafast mode supports global processing and US data residency. EU and other regional inference residency endpoints are not supported.
2. Sol regional availability: For gpt-6.1-sol, Ultrafast mode supports global processing as well as both US and EU data residency.
3. Data residency fee uplifts: As listed on the OpenAI pricing page, regional processing endpoints carry a 10% uplift for models released on or after March 5, 2026. If you require strict EU data residency on gpt-6.1-sol using Ultrafast mode, factor in this 10% pricing uplift.

If your organization requires EU data residency compliance, use gpt-6.1-sol instead of gpt-6-astra when toggling service_tier: "ultrafast".

Error handling and rate limits#

High-speed tiers can exhaust organization tokens quickly or face transient congestion. On September 2, 2026, OpenAI updated its error responses to help applications distinguish rate surges from backend capacity issues:

• HTTP 429 (slow_down): Returned when your application increases request traffic too quickly against your account tier limits.
• HTTP 503 (server_is_overloaded): Returned during temporary model capacity constraints.

Both error codes may include a Retry-After response header. If present, wait the exact duration specified by the header. If the header is missing, fall back to exponential backoff.

Here is an example in plain Python using standard libraries to handle retries cleanly:

import time

def parse_retry_delay(status_code: int, error_code: str, retry_after_header: str | None, attempt: int) -> float:
    # If the server explicitly specifies wait time, always respect it
    if retry_after_header is not None:
        try:
            return float(retry_after_header)
        except ValueError:
            pass

    # Handle overload and rate limit backoff
    if status_code in (429, 503):
        return min(2.0 ** attempt, 30.0)

    return 0.0

# Test exponential fallback when Retry-After is absent
delay = parse_retry_delay(429, "slow_down", None, attempt=3)
print(f"Calculated fallback delay: {delay}s")

If you pair agent backends with voice applications, you can also explore the GPT-Live Decisions integration to run logic asynchronously while streaming audio turns.

Common gotchas with Ultrafast mode#

• Using unsupported models: Specifying service_tier: "ultrafast" on unsupported models (such as gpt-6-luna) will produce a validation error. Stick to gpt-6.1-sol or gpt-6-astra.
• Assuming prompt evaluation is instant: Ultrafast mode accelerates output generation (tokens emitted per second). It does not eliminate the time required for initial reasoning or heavy system prompt evaluation.
• Uncached prefix costs: Ultrafast 12-hour cache writes cost $30.00/MTok on gpt-6.1-sol and $150.00/MTok on gpt-6-astra. Structure prompts so tools, system schemas, and instructions sit at the prompt prefix to maximize cache hit rates.
• Ignoring sandbox idle billing changes: If your agent uses code sandboxes, note that OpenAI updated sandbox billing on October 9, 2026: sandboxes are billed during active turns rather than between idle turns. Pre-warm sandboxes to minimize turn start delays.

Implementation checklist#

Use this checklist before enabling Ultrafast mode across production agents:

• [ ] Set agent.service_tier to "ultrafast" in agent configuration.
• [ ] Verify the agent model is set to either gpt-6.1-sol or gpt-6-astra.
• [ ] Confirm residency requirements: verify US-only residency if deploying gpt-6-astra.
• [ ] Check budget alerts to account for the 6x token cost difference compared to standard tier.
• [ ] Verify error interceptors handle 429 (slow_down) and 503 (server_is_overloaded) using Retry-After headers.

Quick answers