GPT-5.6 Sol Ultrafast: 14x Faster at 750 Tokens Per Second

On August 13, 2026, OpenAI announced Ultrafast mode for GPT-5.6 Sol, a new inference tier that can run the flagship model at up to 750 output tokens per second on Cerebras wafer-scale chips. That works out to roughly 14 times the speed of standard processing.

The interesting part is that OpenAI is not getting that speed by swapping in a smaller model. There is no distilled or quantized version hiding behind the name. Ultrafast is full GPT-5.6 Sol running on a different silicon architecture. The model stays the same; the hardware doing the work changes.

The Cerebras WSE-3: why this chip is different

Most AI inference today runs on NVIDIA GPUs paired with HBM (high-bandwidth memory). The GPU handles the computation, while HBM stores the model weights and other data needed during inference. As the model generates tokens, data has to move between memory and the compute units over and over again.

That movement is one of the big bottlenecks in LLM inference. It is not always about having more raw compute. Memory bandwidth and the cost of moving data around can become the limiting factor.

Cerebras approaches the problem differently. Its WSE-3 (Wafer-Scale Engine 3) is a single, massive processor built across an entire wafer. It has 900,000 cores and 44 GB of on-chip SRAM. Unlike a typical GPU setup, there is no separate HBM layer holding the model weights. The weights can live directly on the processor.

That changes how the data moves during inference. When GPT-5.6 Sol generates a token, the weight data does not need to make the same trip between an external memory system and the processor. The 900,000 cores can access the data through the chip's on-chip interconnects.

The result is lower latency for token generation, which is what eventually allows Ultrafast to reach the reported 750 tokens/sec.

There is another reason this is worth paying attention to. This is the first time OpenAI has offered a frontier model on non-NVIDIA hardware. Cerebras handles the Ultrafast tier, while NVIDIA continues to handle standard and fast processing. The silicon is different, but the model remains the same.

The partnership has been building for months. In early 2026, the two companies signed a reported $10 billion infrastructure deal, and Ultrafast is the first major product to emerge from it.

What the API looks like from a developer's perspective

For developers, switching to Ultrafast is fairly straightforward. The processing tier is passed as a parameter, while the actual hardware routing happens on OpenAI's side.

Here is how the three speed tiers compare:

import openai

client = openai.OpenAI()

# Standard processing — the default
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Analyze this incident log"}],
)

# Fast mode — up to 2.5x faster, ~2x price
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    extra_body={"processing_tier": "fast"},
    messages=[{"role": "user", "content": "Analyze this incident log"}],
)

# Ultrafast — up to 14x faster, Cerebras-powered
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    extra_body={"processing_tier": "ultrafast"},
    messages=[{"role": "user", "content": "Analyze this incident log"}],
)

The application code stays essentially the same. There is no separate model to integrate and no different SDK to learn. The main difference is the tradeoff between how quickly the response arrives and how much the request costs.

OpenAI tested Ultrafast on its Humanity's Last Exam benchmark, which contains 2,500 questions intended to push frontier models hard. Standard processing (Fable 5) took 78 hours to complete the full benchmark. Ultrafast completed it in 11 hours, giving an end-to-end speedup of about 7x.

That 7x figure is worth looking at alongside the 14x token-generation claim. They are measuring different things. Generating tokens faster does not automatically make the entire workload 14 times faster. There is still input processing, reasoning, networking, orchestration, and everything else around the actual generation.

Ultrafast also showed a 5.6x end-to-end speedup on GDP-Val, a benchmark focused on knowledge-work tasks such as document analysis and synthesis. Those results are arguably more useful for developers than a raw tokens-per-second number because they give a better idea of how much time a real task can save.

Where 750 tokens/sec changes what you can build

At 750 tokens per second, the difference is noticeable even with relatively small responses. A 500-token answer can arrive in under a second. A 1,000-token response, such as a detailed code review, incident analysis, or structured market summary, takes around 1.3 seconds at the stated maximum rate.

That starts to change what is practical with a frontier model.

Real-time voice AI. Voice interfaces are extremely sensitive to response latency. If a user asks a question and has to wait three seconds before the model starts answering, the conversation quickly feels unnatural. Ultrafast puts GPT-5.6 Sol into a range where a frontier model can be used for much more responsive voice interaction instead of relying on a smaller model simply because it is faster.

Agentic workflows. Agents can make dozens or even hundreds of LLM calls while completing one task. A typical workflow might involve planning, calling a tool, checking the result, revising the plan, and then validating the final answer. Every call adds some waiting time. When you are running something like a complex research pipeline, a 14x improvement in inference speed can have a noticeable effect on the total runtime.

Financial research and analysis. Financial analysis is often iterative. An analyst might start with an earnings report, ask for a summary, dig into a particular number, change an assumption, and run the analysis again. Faster inference makes this style of work feel more interactive. Instead of sending off a batch job and waiting hours, the analyst can keep exploring the result while the context is still fresh.

Customer support. Where response latency directly affects user satisfaction, Ultrafast brings frontier intelligence into the sub-second range. The difference between a 3-second and a 0.5-second answer in a support chat is not just perception — it changes the flow of the conversation.

Coding assistants. Code completion and refactoring suggestions benefit from the speed, especially in interactive editing environments where the developer is waiting for the model to respond before taking the next step.

Incident response. This is one of the cases where latency can have a very direct operational impact. During an outage, engineers may need to inspect logs, compare traces, form a hypothesis, and test it against more data. OpenAI's own engineering teams use Ultrafast to read logs, analyze traces, and synthesize findings during outages. Cutting the time between each of those steps can turn minutes of waiting into seconds.

The point is not that every application suddenly needs 750 tokens per second. Most applications will not.

What changes is the set of applications where latency stops being an unavoidable limitation and starts becoming something developers can actively optimise around.

Pricing and availability

OpenAI has not published pricing for Ultrafast. Standard GPT-5.6 Sol costs $5 per million input tokens and $30 per million output tokens, while fast mode is roughly twice the price.

Ultrafast runs on specialised wafer-scale hardware rather than the kind of commodity infrastructure used for most GPU workloads. That makes the eventual price particularly interesting. Based on the hardware involved, it is reasonable to expect a premium, although OpenAI has not published an official Ultrafast rate.

Access is currently limited to a select group of API customers. OpenAI has described this mainly as a capacity constraint. Cerebras wafer-scale systems are relatively scarce, so there is only so much Ultrafast capacity available right now. OpenAI says it plans to expand access as more Cerebras infrastructure comes online.

There is also no consumer-facing version at the moment. There is no Ultrafast switch in ChatGPT and no browser extension that enables it. For now, the feature exists inside the OpenAI API and is aimed at developers building production applications where latency is important.

What this signals for the inference market

The interesting part of Ultrafast is not only the speed.

It is the fact that the model and the hardware can be treated as separate pieces of the infrastructure stack. GPT-5.6 Sol can run on NVIDIA GPUs or Cerebras wafer-scale hardware while keeping the same underlying model. The weights are the same. What changes is how those weights are served.

That could make the inference market more competitive. If frontier models can be deployed across several hardware architectures, infrastructure providers have more ways to compete. It is no longer only about who can assemble the largest GPU cluster. Speed, cost and available capacity become just as important.

Cerebras is the first alternative OpenAI has used for this particular frontier-model workload at this scale, but it is unlikely to be the last. If specialised inference hardware can consistently deliver better latency at a reasonable cost, other hardware vendors have a strong reason to chase the same market.

For developers building AI applications, the takeaway is fairly simple: choosing the model is only one part of the infrastructure decision.

The serving layer matters too. Two deployments can use the exact same model and still feel very different to the person using the application because one of them returns an answer much sooner.

Latency and throughput are not determined by model size alone. Hardware architecture, memory design, networking, and the way the model is served all play a part. Ultrafast makes that tradeoff much easier to see.

If you are evaluating AI infrastructure for production systems, Ultrafast is worth testing for workflows where response time directly affects user experience or operational efficiency.

The model is the same. The hardware is not. In a production application, that difference can be just as important as the model itself.