Skip to content

Agents and multimodal systemsAnalysis

Ultrafast mode in an agent loop: which steps earn the 6x price?

Ultrafast speeds up generation, not the whole step, and it bills every step at six times the Standard rate. This analysis models a 10-, 25- and 40-step run and gives a per-step test for where the premium pays.

By INFRO Editorial

Published

8 min read

A glowing autonomous agent core coordinating tools, memory, and multiple AI model routes

In short

Ultrafast multiplies cost on every step it touches but shortens only the generation part of each step, so the gain flattens as runs get longer and tool-heavy while the cost keeps growing linearly. Put it on long-output steps that sit on the critical path, and keep short tool-call steps on Standard.

Key takeaways

  • Ultrafast on GPT-6.1 Sol lists at six times Standard on input, cached input and output, and applies to every step you send through it.
  • Only generation time shrinks; time to first token, tool execution and sandbox waits are the part of a step Ultrafast may leave alone, so step speedup is capped well below the generation speedup.
  • In the illustrative 25-step run, fast-pathing three long-output steps buys 55 seconds for about $0.41 extra, while the other 22 steps cost about $0.034 per second saved, roughly 4.6 times as much.
  • Sandbox time that you stop using offsets at most the sandbox's per-second rate, which is small next to a 6x token premium.
  • Decide per step class with one number: extra cost divided by seconds saved, compared with what a second is worth on that path.

Why a per-request tier comparison misleads for agents

Most comparisons of OpenAI's service tiers price one request: tokens in, tokens out, a latency figure. An agent run is a sequence of those requests, each one carrying the context of the previous ones, with tool execution in between. Two things change when you stack them. Cost grows with every step you send through the premium tier. Time saved does not, because a step is not only generation.

OpenAI's pricing page lists Ultrafast for two models, gpt-6.1-sol and gpt-6-astra. For GPT-6.1 Sol it shows $12.00 input, $0.60 cached input and $60.00 output per million tokens at up to 272K input, against $2.00, $0.10 and $10.00 at Standard and $4.00, $0.20 and $20.00 in Fast mode. For GPT-6 Astra the Ultrafast rows are $60 and $300 against $10 and $50 at Standard 1. That is a uniform six times on every token class. The page also notes that Priority processing was renamed Fast mode on July 30, 2026 1.

OpenAI's Ultrafast guide, as summarized in INFRO's tiers article, recommends WebSockets because without a persistent connection network overhead can reduce the latency gains, and it publishes no current speed figure 2. So the speedup you plan with has to be a parameter you measure, not a number you copy. The rest of this piece treats it as one.

What a step is made of

Break one agent step into four parts:

  1. Time to first token, including queueing and prompt processing.
  2. Generation: output tokens divided by tokens per second.
  3. Tool execution: a shell command, a web fetch, a test run.
  4. Your own overhead: approvals, state writes, network hops.

OpenAI's latency guide is blunt about where time goes. Generating tokens is almost always the highest-latency part of an LLM call, and cutting 50% of output tokens may cut about 50% of latency, while cutting 50% of the prompt may improve latency by only 1–5% 3. A faster tier attacks part 2 and perhaps part 1. It does nothing to parts 3 and 4.

That gives an Amdahl-style ceiling. If generation is a fraction f of a step and Ultrafast speeds it by a factor k, the step speeds up by 1 / ((1 − f) + f / k). With f = 0.65 and k = 5 the step gets about 2.1 times faster; at k = 14 about 2.5 times; the ceiling at infinite k is 1 / (1 − f), about 2.9 times. You pay six times per token for something that, on a typical tool step, cannot reach three times.

The model

Each run has two planning steps, one final answer, and the rest tool-call steps. The "selective" run sends only the three long-output steps through Ultrafast.

StepsStandard cost / timeSelective: extra cost, time savedAll Ultrafast: extra cost, time saved
10$0.15 / 125 s+$0.41, 55 s+$0.76, 66 s
25$0.31 / 236 s+$0.41, 55 s+$1.53, 88 s
40$0.46 / 346 s+$0.41, 55 s+$2.29, 111 s
Illustrative cost and wall time for one run of 10, 25 and 40 steps. Standard cost is model usage only.

Three things stand out. First, the selective strategy's gain is fixed, because it touches the same three steps whatever the run length, so as a share of wall time it falls from about 44% at 10 steps to 16% at 40. Second, going all-Ultrafast adds a share of time saved that also shrinks, from about 52% to 32%, because longer runs are mostly tool calls. Third, the extra cost of all-Ultrafast grows almost linearly with step count, since every added step carries a fivefold premium.

The marginal numbers are the useful ones. In the 25-step run the selective path costs $0.41 for 55 seconds, about $0.0074 per second. The other 22 steps cost $1.12 for 33 seconds, about $0.034 per second, 4.6 times as much. Same tier, same model, very different return.

Where the sandbox bill fits

The Agents API runs the Codex harness as an OpenAI-managed service; OpenAI-hosted sandboxes give the agent a Linux workspace, and model usage is billed at the selected model's API rates while sandboxes use standard container rates 45. The container rates sit in the built-in tools section of the pricing page, which I did not read in full, and I did not confirm the metering unit. So do not hard-code an assumption about how active time is counted; read the rate and test it against a real session's billing.

What you can bound without it: if the sandbox is billed for the time a turn is active, a faster run removes at most (sandbox rate per second × seconds saved). Take an assumed $0.03 per active minute, which is $0.0005 per second. Against the selective path's $0.0074 per second, the offset is about 7%. Against the marginal tool steps at $0.034 per second it is about 1.5%. Even a sandbox ten times that rate would not change the ordering of steps. Sandbox time is a rounding term next to a sixfold token premium, unless your runs are dominated by large containers and long waits, in which case generation is not your bottleneck anyway.

Two lifecycle facts matter more for cost. Connected sandboxes receive keep-alives, including between turns, and one can be deleted after an hour with no activity and no keep-alives; the timeout is not configurable. Deleting the session requests sandbox cleanup, and closing an event stream does not cancel the task 5. A run that finishes quickly but is never deleted still occupies a sandbox. Faster steps do not replace cleanup.

The per-step test

For each step class, compute one number and compare it with a second number you own.

  1. Extra cost per run of the step. Take the step's Standard cost from your traces and multiply by five (Ultrafast price minus Standard, at a uniform sixfold).
  2. Seconds saved. Take measured generation time and multiply by (1 − 1/k). Use your own k, from a small replay, not a vendor ceiling.
  3. Break-even value of a second. Divide 1 by 2. If a second on this path is worth more than that, fast-path it.
  4. Critical path check. Only steps whose output the next step waits on count. A step running in parallel with others adds cost and no wall time.
  5. Visible wait check. If a human reads the output as it streams, the final answer's generation overlaps with reading; the guide notes streaming cuts waiting to a second or less 3. Speed buys less there than the step time suggests.

In the example, break-even values are about $0.43 per minute for a planning step, $0.47 for a final answer and $2.04 for a short tool-call step. A path where one minute of delay costs a user or a deadline more than about $0.50 can justify planning and final-answer steps and still not the tool steps. Your own thresholds will differ; the ranking usually will not.

Before spending anything, check the free options in the same guide: make fewer requests by merging sequential steps into one prompt, parallelize independent steps, use speculative execution for classification steps, and avoid defaulting to an LLM where hard-coding works 3. Each of these shortens the critical path without a premium.

Failure modes to design for

  • Granularity you cannot reach. In a managed Agents API session the harness runs the loop inside a turn 4. I did not confirm whether a tier can be set per internal step. If you can only set it per agent or session, you may need a planning agent on one tier and a tool-runner on another, or your own loop on the Responses API where every request chooses.
  • Undocumented capacity behavior. INFRO's tiers article reports that the Ultrafast guide does not describe what happens when capacity is short, and that Ultrafast has its own rate limits 2. Fast mode, by contrast, is reported to downgrade and bill at Standard. Do not assume the same. Test what your code sees and what is billed.
  • Cache behavior across tiers. Cached input has its own rate at each tier 1. Whether a prefix cached at one tier is reused at another is not something I confirmed; measure it before mixing tiers inside one run, because a cold prefix at six times the rate is the expensive case.
  • Step count drift. Faster steps tempt teams to allow more steps. At a sixfold premium, a bound on steps, time and spend matters more, not less.
  • Silent project-wide enablement. A default tier set on a project applies to every run. INFRO's tiers article notes OpenAI lets you choose which service tiers each project may use 2; see lock down service tiers per project.

Measuring it on your own runs

The test needs per-step data: model, tier, time to first token, generation time, tool time, token counts and estimated cost, joined by run id. INFRO records model, latency, token counts and estimated provider cost per request, with per-request timing detail in traces, and can push spans to your own OpenTelemetry collector; calls from the OpenAI Agents SDK or other Responses API clients can be pointed at INFRO by changing the base URL and key, with budgets refused before the call 6. That gives you the step table above from production traffic without instrumenting the loop yourself; the tool-time column still comes from your own tool spans. Provider usage and costs remain on your own OpenAI account, and the estimate should be reconciled against it. See also tracing an agent run and bounding agent loops.

A practical rollout: replay 50 recorded runs at Standard and with one step class on Ultrafast, compute the two numbers per class, then enable the fast path for the classes that clear your threshold, with a spend cap on the project.

Questions readers ask

Can I switch service tier between steps inside one Agents API turn?
I did not confirm that. The Agents API docs say OpenAI manages sessions, orchestration and recovery for the managed harness, so the loop runs on OpenAI's side 4. Check the API reference for where a tier can be set. If you can only set it per agent, split planning and tool work across agents or run your own loop where each request chooses its own tier.
Does a faster run mean a smaller sandbox bill?
Only by the sandbox's per-second rate times the seconds removed. OpenAI states hosted sandboxes use standard container rates and model usage is billed separately 5. I did not confirm the metering unit, so treat any active-turn saving as a bound, and check the built-in tools rates yourself.

From the team that builds it

Where this shows up in INFRO

INFRO is a control plane in front of the provider accounts you already hold. The capabilities below are the parts of it this article touches, each with the documentation that defines its behaviour.

  • Usage and cost per request

    Available with a plan

    Every request records its model, latency, token or unit counts, and estimated provider cost, queryable by project and key.

    Read the documentation for Usage and cost per request
  • Request traces and payload logs

    Available with a plan

    Per-request timing detail, with prompt and completion logging off by default and a retention window you choose.

    Read the documentation for Request traces and payload logs
  • OpenTelemetry export

    Available with a plan

    Spans pushed to your own collector from the request path, with the endpoint and headers set in the console. Included on every plan.

    Read the documentation for OpenTelemetry export
  • Claude Code and Codex through INFRO

    Available with a plan

    Point Claude Code, the Claude Agent SDK, Codex or the OpenAI Agents SDK at INFRO by changing the base URL and the key. Anthropic's Messages API and OpenAI's Responses API, with routing, budgets refused before the call, guardrails and the request log applied as on every other request.

  • Budgets and spend ceilings

    Available with a plan

    A hard cap per organization, project, member, and key, with alerts at your own thresholds.

    Read the documentation for Budgets and spend ceilings

INFRO accounts are self-serve. Provider usage is billed to you by your providers; INFRO charges a software subscription and takes 0% of model spend. See plans.

Sources

Numbered in order of first citation. Each was opened and checked against the claim on the date shown.

  1. 1.Pricing | OpenAI API (opens in a new tab) — OpenAI. Accessed Nov 6, 2026.
  2. 2.LLM service tiers compared: Flex, Fast, Ultrafast and Priority (opens in a new tab) — INFRO. Accessed Nov 6, 2026.
  3. 3.Latency optimization | OpenAI API (opens in a new tab) — OpenAI. Accessed Nov 6, 2026.
  4. 4.Agents API | OpenAI API (opens in a new tab) — OpenAI. Accessed Nov 6, 2026.
  5. 5.OpenAI-hosted sandboxes (opens in a new tab) — OpenAI. Accessed Nov 6, 2026.
  6. 6.INFRO documentation (opens in a new tab) — INFRO. Accessed Nov 6, 2026.

About this article

Read on 2026-11-06: OpenAI's pricing page (Standard, Fast and Ultrafast tables), latency optimization guide, Agents API overview and OpenAI-hosted sandbox page, plus INFRO's own tiers article and docs overview. openai.com/api/pricing and openai.com/index returned 403, so the developers.openai.com pages were used. The container rate figures, the sandbox metering unit, Ultrafast speed figures and per-step tier selection inside an Agents API turn were not confirmed and are left out or flagged as assumptions; all step timings and token counts are illustrative.

Last checked against its sources on . The next review is due by . No separate named reviewer is recorded for this article.

How articles are written, sourced and corrected is set out in the editorial standards.