Cutting Agent "Wait Time" by 14x: OpenAI Runs GPT-5.6 Sol on Cerebras at 750 Tokens per Second

When you're using a coding agent, isn't the hardest part the "wait" until the model finishes writing its answer? Planning, fixing code, running tests, reading the results, then fixing again—an agent goes through this back-and-forth dozens of times. Because each round adds generation latency, the perceived slowness stacks up. OpenAI's newly announced tier, "Ultrafast," tackles that wait head-on. Using technology from the semiconductor startup Cerebras, it runs GPT-5.6 Sol at up to 750 tokens per second—as much as 14x the standard speed. It's rolling out first as a limited API preview to a subset of customers.

What "Same Intelligence, Just 14x the Speed" Actually Means

The key point is that this isn't a switch to a lighter, separate model. What runs is full-size GPT-5.6 Sol itself, with only the generation speed raised and no drop in accuracy. Since the standard offering is said to run at roughly 50 tokens per second, 750 tokens comes out to about 14x.

The speed comes from Cerebras's distinctive hardware, the wafer-scale engine. In ordinary GPU inference, the bandwidth of shuttling a huge model's weights to and from memory becomes the bottleneck. Cerebras explains that it puts 44GB of SRAM on a single wafer and, keeping the weights on the chip, streams tokens from layer to layer without interruption. This foundation rests on the roughly $10 billion partnership OpenAI and Cerebras struck this year.

Speed Has Now Become a "Paid Tier"

What stands out in this announcement is that OpenAI has carved out speed as something you pay for. Following the same logic cloud providers use to price by performance, even a model with identical intelligence now splits into pricing tiers based on "how fast it returns." Ultrafast's pricing hasn't been disclosed yet, but you can read its positioning from the existing tier structure.

In other words, the picture is: "you can get speed, but that speed comes at a corresponding price." Because it's still in preview, only GPT-5.6 Sol is covered, and access is limited to select customers. OpenAI says it will expand availability as capacity grows.

The "Time Compression" Visible in Benchmarks

The speed pays off more the longer the workload. The measurements cited by OpenAI and Cerebras make this easy to see.

It's the kind of shift where an evaluation that took days now finishes in half a day. And this isn't limited to benchmarks. In workloads like agents that endlessly repeat "generate → execute → generate again," the faster the generation, the shorter the wall-clock time of the whole loop. That translates into a qualitative difference: work you used to run in overnight batches can now be done interactively during the day.

Where It's Useful, from a Developer's View

OpenAI and Cerebras point to the following scenarios where speed pays off.

• Interactive coding: Receiving suggestions without breaking your flow and trying them on the spot. The shorter the wait for an agent's response, the closer you get to the feeling of "staying in the driver's seat while the loop runs."
• Multi-step agent processing: Processes that autonomously repeat planning, implementation, testing, and review. Because the wait at each step accumulates, this is where the speed improvement pays off most.
• Incident response and root-cause investigation: In a production incident, having the model read logs and state and propose hypotheses. A difference of a few minutes directly translates into how fast you can make decisions.
• Security threat detection, and financial or legal analysis: Use cases that call for parsing large volumes of text in a short time.

Caveats Worth Noting Before You Jump In

Speed is appealing, but there are a few things worth keeping level-headed about.

• Fast is not the same as correct: Even if generation gets 14x faster, the correctness of the output doesn't become 14x better. If an agent writes wrong code, it just mass-produces it faster. The safety net of review and testing becomes even more important than before.
• Speed isn't always the bottleneck: In real development, it's not rare for tool execution, file I/O, or network waits—rather than generation itself—to be the rate-limiting factor. You should factor in that speeding up generation won't necessarily speed up the whole by the same multiple.
• Price as a new variable: With speed becoming a separate billing tier, a new judgment call is added: "how much speed, for how much money." With pricing undisclosed for now, the cost-effectiveness is still unreadable.
• Concentration of supply: This speed rests on one vendor's dedicated hardware. Including the fact that capacity is throttled in a limited preview, the growing dependence on a single supplier is something to keep in mind.

Even so, the significance of this move is that the option of "buying just speed while keeping the same intelligence" has appeared as a formal tier. For teams that keep agents running, wait time is a number that affects both productivity and cost. How much that speed will cost—the price tag that follows the preview will be the deciding line on whether it makes it into production.

References: Previewing Ultrafast mode (OpenAI) / Accelerating GPT-5.6 Sol Ultrafast (Cerebras) / The Decoder / Help Net Security / MLQ News