OpenAI's new Ultrafast service tier runs GPT-5.6 Sol up to 14x faster than standard processing, up to 750 output tokens per second, on Cerebras hardware. Most of your agent loop won't get 14x faster, and one measurement tells you whether yours is the exception.

That measurement is the split between time your agent spends waiting on the model and time it spends waiting on everything else: HTTP calls, database queries, browser automation, sandboxed code runs. Get that ratio first. Everything else, pricing, tier migration, whether the quality claim holds, is downstream of it.

What Ultrafast actually speeds up

The 750 tokens/sec figure is an output generation rate. It's the speed at which tokens come off the chip once generation has started. It says nothing about time-to-first-token, nothing about how long the model takes to ingest a 60k-token context, and obviously nothing about how fast your Postgres query returns.

The speedup is architectural, not a smaller model. Cerebras keeps model weights on-chip in 44GB of SRAM instead of shuttling them from high-bandwidth memory (HBM) on every forward pass (Neowin, byteiota). That matters: it's the same weights, so reasoning-heavy work is in scope, not just short chat completions.

Why some loops win big and others don't move

Split agent loops into two shapes.

Model-time dominated. Generate → critique → regenerate. A self-correction loop with no external calls between steps. Every step in the critical path is token generation, so a 14x generation speedup is close to a 14x wall-clock speedup. This is the pattern Ultrafast was built for, and it's the honest version of the "agentic loops become viable" framing.

Tool-time dominated. The agent searches the web, writes to a database, runs code in a sandbox, clicks through a browser. The model emits a 40-token tool call in 50ms, then waits 3 seconds for the tool. The model was never the long pole. Making it 14x faster shaves milliseconds off a loop measured in seconds.

This is Amdahl's law wearing an agent costume: speeding up the fast part of a system doesn't shrink a system dominated by the slow part. None of the launch coverage says this, because it's the inverse of the vendor framing.

One pattern sits between them. Speculative tool calling, generating the probable next tool call before the previous result returns, then discarding it when the guess is wrong, is only economical when a wasted generation is cheap in time and money. Ultrafast-class throughput is what makes that trade tilt. To be clear: that's an architectural implication I'm reasoning to, not a shipped OpenAI feature.

Profile your loop before you pay for the tier

Wrap timestamps around every model call and every tool call. Twenty lines of Python, and it answers the whole question.

agent_timing.py, split a trace into model time vs tool time
import time
from collections import defaultdict
from contextlib import contextmanager

spans = defaultdict(float)

@contextmanager
def track(kind: str):
    start = time.perf_counter()
    try:
        yield
    finally:
        spans[kind] += time.perf_counter() - start

def report() -> None:
    total = sum(spans.values())
    for kind, seconds in sorted(spans.items(), key=lambda kv: -kv[1]):
        print(f"{kind}_time: {seconds:.2f}s ({seconds / total:.0%})")
    print(f"total: {total:.2f}s")

# Usage inside your loop:
# with track("model"):
#     response = client.responses.create(model="gpt-5.6-sol", input=history)
# with track("tool"):
#     call = next(item for item in response.output if item.type == "function_call")
#     result = run_tool(call)

Run that over ten representative traces, not one. A single trace with a cold cache or a slow API will lie to you. What you want is a stable line like model_time: 3.2s (22%) / tool_time: 11.4s (78%).

Then do the break-even arithmetic. Take a 5-step loop generating 600 output tokens per step. At 53 tok/s that's 56.6s of model time. At 750 tok/s it's 4.0s.

Wall-clock speedup as tool time grows
model_slow = 5 * 600 / 53     # 56.6s of generation at the standard tier
model_fast = 5 * 600 / 750    # 4.0s at 750 tok/s

for tool_share in (0.0, 0.30, 0.70):
    tool = model_slow * tool_share / (1 - tool_share)
    speedup = (model_slow + tool) / (model_fast + tool)
    print(f"tool={tool_share:.0%} -> {speedup:.2f}x wall-clock")

# tool=0%  -> 14.15x
# tool=30% -> 2.86x
# tool=70% -> 1.39x

At 70% tool time, which is a conservative estimate for anything doing real web or database work, a 14x model speedup buys you 1.39x. Your loop goes from 189 seconds to 136. Real, but not the number in the headline, and probably not the number you'd change vendors over.

Treat "no quality compromise" as a claim, not a fact

OpenAI says there's no quality trade-off on Ultrafast. That's a vendor statement, not an independently verified benchmark result at time of writing. Practitioners on Hacker News point at the track record, the GPT-3.5-turbo transition, the undocumented GPT-4-Turbo checkpoint swaps, as grounds for measuring rather than trusting. That's informed skepticism, not evidence that anything is wrong with GPT-5.6 Sol.

The compounding risk is specific and worth naming. If your reason to adopt Ultrafast is a self-correction loop, you're running the model 3–5 times over its own output. A small per-call quality regression that's invisible in a single completion becomes visible after the third critique pass, because each iteration builds on a slightly worse input. Run your existing eval set at both tiers, same prompts, same seeds where you can pin them, and compare end-of-loop output, not step-one output.

Inference speed is a multiplier on one term in your latency budget, and you can't know if that term matters without measuring it. Drop the timing harness into your agent Monday morning, run ten traces, and read the split: if tool_time is above 50%, Ultrafast is solving a problem you don't have, go fix your tool round-trips instead.