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:
- Time to first token, including queueing and prompt processing.
- Generation: output tokens divided by tokens per second.
- Tool execution: a shell command, a web fetch, a test run.
- 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.
| Steps | Standard cost / time | Selective: extra cost, time saved | All 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 |
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.
- 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).
- Seconds saved. Take measured generation time and multiply by (1 − 1/k). Use your own k, from a small replay, not a vendor ceiling.
- Break-even value of a second. Divide 1 by 2. If a second on this path is worth more than that, fast-path it.
- 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.
- 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.
