OpenAI is serving its biggest model at 750 tokens a second on Cerebras — speed is now the third axis of the AI race

What Cerebras and OpenAI announced

GPT-5.6 Sol is OpenAI’s most capable model — and, like most frontier models, it is the one you reach for on the hardest problems and then wait on. On 13 August 2026, Cerebras said it is now serving Sol on a new OpenAI service tier called Ultrafast, generating up to 750 output tokens per second, which OpenAI puts at roughly 14× the Standard tier’s speed. The model is identical; what changes is the hardware underneath and, with it, how fast tokens come out.

That number is not incremental. At Standard rates, a frontier model streams at roughly reading pace — fine for a chat reply, painful for a multi-step agent that generates thousands of tokens across many tool calls. At 750 tokens per second, the same output arrives faster than you can read it, which is the point: it moves a frontier model out of “submit and wait” territory and into real-time interaction. Two OpenAI staff framed it in exactly those terms. Rohan Varma, on OpenAI’s product side, said Ultrafast “enables AI that keeps up with how you think, code, and collaborate,” and researcher Jeffrey Wang described the shift bluntly: “Whereas formerly I might have to wait a couple minutes for a task to finish, it now finishes before I even have opportunity to context-switch.”

Ultrafast launches first in the OpenAI API as a limited preview for a select group of customers, with access expanding as Cerebras adds capacity. Crucially, the announcement did not include a separate Ultrafast price, a list of supported regions, or an uptime commitment — a point TechTimes flagged in its headline. Standard GPT-5.6 Sol is $5 per million input tokens and $30 per million output; whether the fast tier carries a premium is the one number that would decide how useful this is for cost-sensitive work, and it is missing.

Why a small chipmaker can serve OpenAI’s biggest model this fast

The interesting engineering question is how a company far smaller than Nvidia is serving OpenAI’s flagship at these speeds. The answer is that fast inference on a large model is fundamentally a data-movement problem, not a raw-compute one.

On a GPU, a model’s weights live in off-chip high-bandwidth memory. To generate each token, those weights have to be streamed onto the chip, used, and streamed back — over and over. As models grow, memory bandwidth, not arithmetic, becomes the ceiling on how fast tokens can come out. Cerebras’s answer is to remove the movement entirely. Its Wafer-Scale Engine is a single chip the size of a dinner plate carrying roughly 44 GB of SRAM on-die, enough to hold the working weights on-chip so they never have to be shuttled. Eliminate the round trips and the token rate jumps — which is why Cerebras, and not a bigger GPU fleet, is the one hitting 750 tokens per second on a frontier model.

Cerebras backs the claim with benchmark timings. On GDP-Val, it reports a 5.6× end-to-end speedup over Standard with no quality loss — the important qualifier, since a fast tier that quietly degrades answers would be worthless. It also published head-to-head completion times against Anthropic’s models as competitive framing: Sol-on-Cerebras finishing the 2,500-question Humanity’s Last Exam in 11 hours 11 minutes versus 78 hours 27 minutes for Claude Fable 5 (nearly 7× faster), and claims of roughly 11× faster than Fable 5 and 5× faster than Opus 4.8 on Fast mode on its throughput tests. Treat the cross-vendor comparisons as Cerebras’s own framing rather than neutral results — they compare a specialized speed tier against competitors’ standard serving — but the direction is consistent and the no-quality-loss point is the one that matters.

Speed becomes the third axis

Step back and the significance is not one tier on one model. It is what the industry is now competing on.

For two years the frontier race was about intelligence — who topped the benchmark this month. That lead has become perishable; a new #1 lasts weeks, not quarters. So over the last six weeks the race moved to price, culminating in this month’s repricing where OpenAI, Anthropic and Google cut hard while DeepSeek raised. Ultrafast is the clearest sign yet of a third axis opening up: latency. When two models are close on capability and converging on price, the one that answers in real time wins the workloads that actually generate revenue — coding assistants, voice agents, and the multi-step agentic loops that dominate token usage today.

This is also a strategic tell about inference silicon. OpenAI is willing to route its most capable model onto a third party’s non-GPU hardware to win on speed. That does not mean it is leaving Nvidia — the bulk of its serving is unchanged — but it does mean the flagship is no longer wedded to a single stack, and that specialized inference chips have crossed the threshold from “interesting” to “serving the frontier in production.” For a market where compute supply is the binding constraint on everyone’s roadmap, that is a meaningful diversification.

Why this matters

1. Latency changes what you can build, not just how long you wait. An agent that plans, calls tools and revises over dozens of steps compounds every per-token delay into minutes of wall-clock time. Collapse that to near-real-time and the interaction model changes — you supervise less and converse more. If your product’s usefulness is currently capped by how long a frontier model takes to respond, this is the constraint being attacked directly. Tools like Cursor and Claude Code live and die on exactly this loop latency.

2. It is a preview, so it is a signal — not a plan. No price, no SLA, no regions, limited access. You cannot responsibly build a product on a tier with those gaps, and you should not. What you can do is factor the trajectory into roadmap decisions: real-time frontier inference is arriving, and the workloads it unlocks (live voice, interactive agents, fast coding loops) are worth prototyping now against whatever fast serving you already have.

3. The missing price is the whole ballgame. Speed you can’t afford is a demo. This lands in the same week the market decided cost per unit of useful work is the metric that matters — so an Ultrafast tier with an undisclosed premium sits awkwardly against that current. Watch for the number. If it is close to Standard, it reshapes agentic economics; if it is a steep premium, it stays a niche for latency-critical, price-insensitive use.

4. Supply is the quiet constraint. The reason this is a limited preview is almost certainly capacity: wafer-scale chips are specialized and not made in GPU-scale volumes. That caps how fast Ultrafast can generalize, and it makes Cerebras a single, relatively small supplier in the critical path. Redundancy and a fallback path matter if you ever depend on it.

Honest caveats

• Preview, not GA. Limited to select OpenAI API customers, expanding “as capacity grows” — no committed timeline.
• No price, no SLA, no region list. The three facts a buyer needs to plan around are all absent. Until the price is public, the value is unknowable.
• “Up to 750 tps” and “up to 14×” are ceilings. Real-world sustained rates depend on context length, load and prompt shape; expect the typical case to sit below the headline.
• The comparison numbers are Cerebras’s own. The GDP-Val, Humanity’s Last Exam and cross-vendor speed figures are first-party, pitting a specialized speed tier against competitors’ standard serving. The “no quality loss” claim is likewise self-reported and unverified independently.
• Single specialized supplier. Wafer-scale capacity is the bottleneck and Cerebras is one company; concentration and supply risk are real if this becomes load-bearing.

The verdict

GPT-5.6 Sol Ultrafast is the most concrete evidence yet that speed is joining intelligence and price as a front-line axis of AI competition — and that frontier-scale, real-time inference on non-GPU silicon is now a production reality, not a lab demo. For anyone building agents, coding tools or voice products where latency is the ceiling on usefulness, this is the constraint you have been waiting to see attacked. The recommendation is measured: treat it as a preview of where inference is heading, prototype the real-time workloads it points to, and hold off on any architecture that depends on it until OpenAI attaches a GA date and a price. Speed changes the product; the price will decide whether it changes the market. For where the flagship sits today, see the GPT-5.6 launch breakdown and the best AI coding tools guide.

Questions or corrections? Email Pick Right. Want the full list? See all news.