GPT-5.6 Soul Ultrafast: 14x Speed via Cerebras Explained
OpenAI's Ultrafast mode runs GPT-5.6 Soul on Cerebras chips at up to 14-15x normal speed, turning long agent tasks into short ones.
What is GPT-5.6 Soul Ultrafast mode?
GPT-5.6 Soul Ultrafast is a preview mode that runs OpenAI’s Soul model on Cerebras hardware instead of standard GPU infrastructure, cutting response time dramatically. In hands-on comparisons, a prompt that took regular Soul over 12 minutes finished in under 2 minutes on Ultrafast, roughly 14 to 15 times faster. The catch is cost: running on Cerebras’ specialized chips costs more per token than standard inference, and as of now it’s only available in preview.
TL;DR
- Ultrafast mode runs GPT-5.6 Soul on Cerebras chips instead of standard GPU clusters, delivering roughly 14 to 15 times the speed of regular Soul on identical prompts.
- A head-to-head test building a financial terminal dashboard finished in 1 minute 50 seconds on Ultrafast versus over 12 minutes on standard Soul.
- The partnership with Cerebras was announced months before this launch, and Cerebras is widely regarded as the fastest inference provider currently in operation, using custom wafer-scale chips rather than traditional GPUs.
- Speed changes how developers use parallel agents: instead of running ten agents at once to compensate for long wait times, a few fast agents can now cover the same ground.
- Faster inference exposes a new bottleneck: tool calling, file I/O, and other CPU-bound steps now take longer relative to the model’s actual “thinking” time.
- The mode is priced at a premium and currently limited to preview access, so it’s not yet a default replacement for standard Soul.
- The shift toward speed-optimized inference signals a broader move toward cloud-based agent execution, since local machines increasingly can’t keep pace with model throughput.
Remy is new. The platform isn't.
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
How does Cerebras make GPT-5.6 Soul faster?
Cerebras builds inference hardware around a wafer-scale chip design, which packs far more compute onto a single piece of silicon than the array of smaller GPU chips typically used for LLM inference. Instead of splitting a model’s workload across many separate GPUs connected by networking that introduces latency, Cerebras keeps more of the computation on one massive chip, reducing the back-and-forth data movement that slows things down.
OpenAI’s partnership with Cerebras, announced ahead of this launch, pairs GPT-5.6 Soul with that hardware to produce the Ultrafast mode. The model itself isn’t different in terms of capability. It’s the same Soul model, just executed on infrastructure built specifically to move tokens faster. That distinction matters: this isn’t a smaller or distilled model trading quality for speed, it’s the same weights running on faster silicon.
How much faster is it in practice?
In a direct comparison, a prompt asking for a financial terminal style dashboard for financial analysts was sent to both standard Soul and Ultrafast Soul at the same time. Ultrafast finished the entire build in 1 minute 50 seconds. Standard Soul was still working at the 7, 8, and 9 minute marks, and didn’t complete until 12 minutes 20 seconds. That works out to roughly a 6.7x wall-clock improvement on this particular task, though the creator running the test described the underlying speed multiplier as closer to 14 to 15 times based on raw token throughput, with some of that advantage absorbed by non-model steps like tool calls.
That gap between raw model speed and total task time points to something important: once the language model itself stops being the slow part, everything else in the pipeline becomes the new constraint.
Why does agent speed matter more than raw model quality here?
Anyone who has run coding agents like Codex knows the routine: submit a prompt, wait 30, 60, sometimes 90 minutes, then come back to review the output. That waiting time has shaped how people work with agents. Rather than babysitting one agent, many developers now kick off five, eight, or ten agents in parallel, treating the long wait as an opportunity to multitask across projects.
Ultrafast mode disrupts that pattern. If a task that used to take 30 minutes now takes two or three, the incentive to run ten parallel agents drops. Context-switching between many simultaneous agent threads is mentally taxing, and developers who tried Ultrafast in preview described a shift toward running just two or three agents at a time instead, since each one now returns results fast enough to actually watch and react to.
This changes agent workflows at a structural level. Speed doesn’t just save time, it changes the shape of how people plan and supervise AI-driven work.
What’s the new bottleneck once the model gets this fast?
One coffee. One working app.
You bring the idea. Remy manages the project.
With Ultrafast mode, the language model’s “thinking” is no longer the slowest part of the process. Tool calling, file operations, and other steps that rely on traditional CPU-bound code now take up a larger share of total task time. This matches a comment from a member of OpenAI’s Codex team, made a few weeks before Ultrafast launched, suggesting that next-generation models need more compute than a typical laptop can provide.
That statement makes more sense in light of Ultrafast mode. When a model can generate and reason through a task in seconds, the surrounding infrastructure, your local machine, your terminal, your file system, becomes the drag on performance. It’s a reversal of the usual assumption that GPUs or inference chips are always the limiting factor. Increasingly, the bottleneck sits closer to the user’s own hardware, which pushes more of the workflow toward cloud-based execution where everything, including tool calls, can run at matching speed.
Is Ultrafast mode worth using right now?
For workflows involving long-running agent tasks, especially coding or multi-step research, Ultrafast mode offers a clear practical benefit: tasks that used to require stepping away from the computer now finish while you’re still watching. That changes the calculus around how many parallel agents you need to run to stay productive.
The tradeoffs are real, though. Ultrafast costs more per token than standard Soul, and it’s currently limited to preview access rather than general availability. For simple queries or low-stakes tasks, the extra cost may not be justified. But for anyone running long, complex agent chains where time is the actual bottleneck (not just compute cost), the speed gain is large enough to change daily workflow habits, not just shave a few seconds off a response.
Whether it becomes a standard option or stays a premium tier will likely depend on how Cerebras and OpenAI price it as it moves out of preview.
Frequently Asked Questions
What is the actual speed difference between Ultrafast and standard Soul?
In a direct test building the same dashboard application, Ultrafast Soul finished in 1 minute 50 seconds while standard Soul took 12 minutes 20 seconds. The underlying token generation speed was described as roughly 14 to 15 times faster, though real-world task time also depends on tool calls and other non-model steps.
Does Ultrafast mode use a different, smaller model?
No. It runs the same GPT-5.6 Soul model, just on Cerebras hardware built for faster inference rather than standard GPU infrastructure. Model capability isn’t reduced, only the execution speed changes.
Why would tool calling become a bottleneck if the model is faster?
Once the language model itself generates tokens almost instantly, the remaining steps in a task, like reading files, running terminal commands, or calling external tools, take up a larger proportion of total time since those steps still run on traditional CPU-based systems that haven’t sped up in the same way.
Is Ultrafast mode available to everyone?
It’s currently in preview, meaning access is limited and pricing runs at a premium compared to standard Soul. It hasn’t been confirmed as a general availability feature yet.
How does this affect running multiple AI agents at once?
Because tasks complete much faster, developers who previously ran many agents in parallel to compensate for long wait times can run fewer agents and still get comparable throughput, reducing the mental overhead of switching between multiple active agent sessions.
