OpenAI's Ultrafast Mode Ended the Speed-vs-Intelligence Tradeoff. Access Is the New Bottleneck.

GPT-5.6 Sol now runs at up to 750 output tokens per second on Cerebras hardware. There is no price, no launch date, and a waitlist. Here is what it actually changes in agent design, and what to do while you wait.

GPT-5.6 Sol answered all 2,500 questions on Humanity's Last Exam in 11 hours and 11 minutes. Claude Fable 5, working the same set, needed 78 hours and 27 minutes to reach what the benchmarker calls comparable accuracy. Three days of continuous compute against what Cerebras describes as a single working day.

Cerebras ran that benchmark and published it, so hold the number loosely. The thing underneath it survives the discount anyway: the fast run was not a smaller model. It was the same frontier model, on different silicon, sold as a different service tier.

That is the announcement. Everything else is detail.

Why this breaks an assumption you have been designing around

For two years, "make it faster" has meant "make it dumber." You route the easy turns to a mini model. You cascade, drafting with something small and escalating when confidence drops. You run four agent sessions in parallel so there is always one you can look at while the others think. You put a spinner on the UI and hope the user stays.

Every one of those patterns is scaffolding built around a single constraint: frontier intelligence is slow, so buy latency with capability. OpenAI's Ultrafast preview, published August 13, says that constraint has a price now instead of a workaround. Same model, different tier, up to 14 times the speed of Standard processing.

Do the arithmetic on the 14x and Standard lands somewhere around 54 output tokens per second. That is my division, not a figure OpenAI published, so treat it as a rough anchor rather than a spec. The ratio is the claim they are making, and the ratio is what matters to your architecture.

Worth being precise about what is new here, because Ultrafast is the third rung, not the first. On July 30 OpenAI renamed Priority processing to Fast mode and pushed it to roughly 2.5 times Standard speed on the same Sol model, at twice the Standard price. So a paid speed tier already existed two weeks before this announcement. What Ultrafast changes is the method. Fast mode buys you queue position and scheduling on GPUs. Ultrafast moves the model onto different silicon entirely, and the jump from 2.5x to 14x is the difference between tuning a bottleneck and removing it.

One quote in the Cerebras post says more about the product than any benchmark. Jeffrey Wang, an OpenAI researcher, describes tasks finishing "before I even have the opportunity to context-switch." Parallel agent sessions exist because waiting is expensive. When waiting gets cheap, the reason you built the parallel harness goes away, and you are left maintaining coordination logic for a problem you no longer have.

The mechanism, and why it is a hardware story

Fast inference on large models is a data movement problem. On GPUs, generating each successive token means pulling model weights between on-chip memory and off-chip storage, over and over. Memory bandwidth, not raw compute, sets the ceiling. Bigger model, more weights to move, slower tokens.

Cerebras takes the opposite bet. Its engineering post describes packing 44 GB of SRAM onto a single wafer-sized chip so the weights stay resident, with tokens flowing through layers pipelined across wafers. No round trip to HBM, no bandwidth wall in the inner loop. The company's argument is that this scales with model size rather than against it, which would mean the speed gap widens on future frontier models instead of closing.

Whether that holds is a question for 2027. What is checkable today is the commercial shape underneath it. OpenAI and Cerebras announced a partnership on January 14, 2026, covering 750 megawatts of low-latency compute, coming online "in multiple tranches through 2028." So when both companies write that access will expand "as capacity grows," that is not a marketing hedge. It is a construction schedule. The waitlist is gated by concrete and power, not by product readiness.

That reframes the whole release. Ultrafast is not a feature launch. It is the first customer-visible output of a multi-year hardware commitment, shipped early to a handful of design partners so OpenAI can learn which workloads justify the allocation.

What it is actually for

The named early customers point at a pattern: Jane Street on coding, Podium on voice, Basis on synchronous product experiences, Rogo on financial research. Every one of those is a workload where a human is waiting in real time.

OpenAI's own internal use is the clearest case. During an incident, engineers use Ultrafast to read logs, analyze traces, synthesize the conversation, and propose next checks while the outage is still moving. The value is not that the answer is better. It is that the answer arrives before the system state changes underneath it.

Basis co-founder Mitch Troyanovsky puts the constraint precisely in OpenAI's post: the barrier to fast products was never tokens per second alone, it was getting speed and intelligence in the same call. A voice agent that responds in 400 milliseconds with a shallow answer loses the call. One that responds in eight seconds with a good answer also loses the call.

Put this into practice

You almost certainly cannot get Ultrafast today. That is fine, because the useful work is preparation, and it is work worth doing whether or not you ever get access.

1. Get on the list, then forget about it. OpenAI has a signup form. Two minutes. Do not plan a quarter around it.

2. Measure where your latency actually goes. This is the step most teams skip and the one that decides whether Ultrafast helps you at all. For one representative agent run, log time-to-first-token, output tokens per second, total tool-call wall time, and network wait. If your agent spends nine seconds calling your own Postgres and three seconds generating tokens, a 14x generation speedup buys you under three seconds on a twelve-second loop. Ultrafast accelerates output generation. It does not accelerate your database, your vector store, or the third-party API that rate-limits you.

3. Tag every place you downgraded a model purely for speed. Go through your routing config and mark each rule that sends work to a smaller model for latency reasons rather than cost reasons. Those are the rules that become deletable. Cost-motivated routing survives this change untouched, because nobody has said what Ultrafast costs.

4. Find your one latency-bound workload. Not your whole system. One flow where a human waits and the wait is the product problem. Support handoff, checkout assistance, incident triage. That is the flow you would actually pilot with, and having it named makes the access conversation short.

5. Price the interim option on that workload. Fast mode is generally available right now at 2.5x speed for 2x price, no waitlist. Run it on the flow you just named for a week. You will learn whether speed is worth real money to you before the bigger tier ever opens up, and if the answer is no, you can stop reading about Ultrafast entirely.

6. Write down what you would do with the saved time. If your research loop currently runs overnight and returns in the morning, what does a same-day loop change about how many hypotheses you test? OpenAI reports exactly this shift internally. If you cannot answer the question, the speed is not worth paying for yet.

Steps two and three take an afternoon. Those are the ones I would not skip.

Honest limitations

There is no price. Not "pricing coming soon." No number at all. The only anchor anyone has is the rung below it: Fast mode charges 2x for 2.5x. Apply that shape naively to 14x and the number gets frightening. Apply it generously and it still lands well above Standard. Every architectural decision you might make on the strength of this announcement is a decision made without the cost column, and the cost column is the one that decides whether any of it ships.

There is no date, no SLA, and no regional availability. Limited preview, select customers, expansion as capacity grows. For anything with a compliance or data-residency requirement, this is not yet a thing you can evaluate.

The benchmarks are the vendor's own, and they compare harnesses as much as models. Cerebras ran the HLE comparison using Sol Ultrafast inside Codex on xhigh reasoning on July 10, against Claude Fable 5 inside Claude Code on xhigh reasoning on July 13 through 15. Different harness, different day, self-reported by the party selling the hardware. The GDP-Val result, a 5.6x end-to-end speedup with no reported quality loss, comes from Cerebras testing on July 31 at medium reasoning inside Codex. Directionally interesting. Not independent.

It is one supplier. OpenAI's compute strategy is deliberately a portfolio, but Ultrafast specifically runs on Cerebras and only Cerebras. A tier that fast, delivered by one company on one architecture, on a buildout schedule that runs to 2028, is a dependency you should name out loud before you put it on a critical path.

Speed compresses your review window. This is the tradeoff nobody in the announcement wants to sit with. OpenAI's own framing says engineers stay responsible for judgment and deployment, and the flagship use case is incident response, where an agent now proposes a fix faster than a tired human at 3 a.m. can read it. A wrong action at 750 tokens per second is a wrong action you have less time to catch. Every approval gate you built assuming a few seconds of thinking time was a few seconds of human reading time too. Those gates need to hold at the new speed, and most of them were never tested there.

What I would watch

The number I care about is not tokens per second. It is what happens to the small-model tier once frontier speed is purchasable.

Right now a large chunk of the mini and flash model market exists because latency forced people down the capability curve. If speed becomes a line item on the frontier model instead, the honest reason to run a small model narrows to cost and to running it on your own hardware. That is still a good reason. It is a much smaller reason than the one that built the category.

So the question I would put to your own stack: if the fast path and the smart path became the same path tomorrow, how much of what you built this year was compensating for a constraint that is on a decommissioning schedule? Go count. The answer is probably uncomfortable, and it is better to know before the price shows up.

Sources: OpenAI, "Previewing Ultrafast mode" (August 13, 2026); Cerebras, "Accelerating GPT-5.6 Sol Ultrafast" (August 13, 2026); OpenAI, "OpenAI partners with Cerebras" (January 14, 2026); OpenAI, "Fast mode for API Customers". Fast mode speed and pricing ratios as reported at the July 30, 2026 rename from Priority processing.