TL;DR: OpenAI is running GPT-5.6 Sol on Cerebras wafer-scale chips at up to 750 tokens/second in Codex — roughly 10× the 40–120 tok/s a frontier model streams from a GPU cluster. That kills the output-streaming bottleneck for agentic sessions. It does not change your bill: Sol is still $5/$30 per million tokens whether it streams fast or slow, and access is gated to a handful of partners in July.

	Sol on Cerebras	Sol on GPU (typical frontier)	Local model (RTX 5090)
Output speed	Up to 750 tok/s	40–120 tok/s	~40–100 tok/s (30B-class)
Price / 1M tokens	$5 in / $30 out	$5 in / $30 out	$0 marginal
Best for	Latency-bound agentic runs	Everything else on Sol	Privacy, offline, zero-cost
The catch	Limited-partner rollout in July	Slow streaming on long output	Quality gap vs frontier

Honest take: 750 tok/s is the right direction for agentic coding — when an agent writes a 5,000-token file, you want it in 7 seconds, not 90. But in July 2026 almost no Cursor or Cline user can touch it: it’s a limited Codex/API preview. Don’t restructure your workflow around a number you can’t access yet. If raw speed is what you’re chasing today, a local model on your own GPU already streams faster than a GPU-served frontier model — just at lower quality.

What OpenAI actually confirmed

Cutting through the hype thread that put this on Hacker News: OpenAI has said GPT-5.6 Sol — the flagship tier of the GPT-5.6 family it previewed on June 26, 2026 — will be served on Cerebras wafer-scale hardware at up to 750 tokens per second, rolling out in July through Codex and the API to a limited set of customers while Cerebras scales capacity.

Two numbers anchor everything below, and both are verified against multiple independent reports today (July 8, 2026):

• 750 tok/s is the peak Cerebras output rate for Sol. It’s “up to,” not guaranteed — a ceiling, not a floor.
• 40–120 tok/s is the range a frontier-class model typically streams from an Nvidia GPU cluster in production. So Cerebras is roughly a 10× speedup on the same weights — same model, same answers, faster delivery.

Independent estimates (from Cerebras-watcher Bleys Goodson) put Sol’s serving footprint at 70–100 wafers, one model layer per wafer, implying something like 3T total parameters with ~150B active across 70 layers. Treat that as an educated guess, not an OpenAI spec — but it explains why the rollout is capacity-constrained: wafer-scale silicon is scarce, and a single frontier model eats most of a deployment.

This is not OpenAI’s first Cerebras rodeo. Back on February 12, 2026, it shipped GPT-5.3-Codex-Spark — a smaller, coding-tuned model — at over 1,000 tok/s on the same Cerebras WSE-3 hardware, roughly 15× the ~65–70 tok/s of the full GPT-5.3-Codex. Codex-Spark was the proof of concept. Sol on Cerebras is the same trick applied to a frontier model.

Why 750 tok/s matters for agentic coding (and where it doesn’t)

Here’s the thing most speed coverage gets wrong: raw tok/s only matters when output streaming is your bottleneck. For agentic coding, sometimes it is, and sometimes it very much isn’t.

Where speed wins big — long single generations. When an agent rewrites a 400-line file, that’s ~5,000 tokens of output in one shot. On a GPU streaming at 80 tok/s, you wait about 62 seconds. On Cerebras at 750 tok/s, you wait about 7 seconds. Do that fifteen times in a refactoring session and you’ve reclaimed the better part of fifteen minutes of thumb-twiddling. For the “generate a whole module, then the tests, then the migration” pattern, wafer-scale is a genuine quality-of-life jump — you stay in flow instead of watching a spinner.

Where speed barely moves the needle — tool-heavy agentic loops. A real agentic run isn’t one long generation. It’s: read three files, think, call a tool, read the result, think, write a patch, run the tests, read the failures, patch again. Most of the wall-clock time is round-trip latency and reasoning, not token streaming. Once the streaming bottleneck disappears, the new bottleneck becomes thinking time between steps and the latency of tool calls (test runs, file reads, shell commands). A 10× streaming speedup on a workflow that’s only 30% streaming gets you nowhere near 10× faster end to end.

So the honest framing: Cerebras-served Sol is a latency upgrade for generation-heavy work, not a magic “10× faster coding” button. If your agent spends its life running your test suite, the test suite is still the slow part.

The part that doesn’t change: your bill

This is the correction the excited threads need. Serving speed and per-token price are independent. Sol is priced at $5 per million input tokens and $30 per million output tokens — and that’s the price whether the tokens arrive at 80 tok/s from a GPU or 750 tok/s from a wafer. Cerebras makes tokens arrive faster; it does not make them cheaper.

That matters because output tokens on Sol are expensive, and speed can quietly make you spend more of them (faster iterations, more attempts per hour). Rough cost of a few realistic Codex sessions at Sol pricing:

Session type	Input tokens	Output tokens	Cost
Interactive edit burst	200K	25K	~$1.75
Medium agentic task (~100 steps, lots of context re-reads)	1M	100K	~$8.00
Large multi-file refactor session	2M	300K	~$19.00

In agentic coding, input tokens usually dominate — the agent re-reads context on every step — so the $5/M input side is what actually runs up the bill, not the flashy output number. If you’re cost-sensitive, the speed of the output stream is almost irrelevant to what you pay. This is exactly why we argued in our GPT-5.6 Sol/Terra/Luna pricing breakdown that Terra ($2.50/$15), not Sol, is the tier that changes most developers’ bills.

Break-even sanity check: a flat-rate Cursor Pro plan at $20/month covers a lot of coding before per-token API billing wins. If your month looks like a few medium agentic tasks a day, BYOK Sol will blow past $20 in under a week. Flat-rate plans exist precisely to cap this — see our AI code editor cost comparison for where the lines cross.

The access reality — who actually gets this in July

Read this before you get excited. GPT-5.6 Sol is a limited preview, available through the API and Codex to a select group of trusted partner organizations during the rollout, with broader availability across ChatGPT, Codex, and the API planned for “the coming weeks.” The Cerebras-served, 750 tok/s version is even more constrained, because it’s gated by how many wafers Cerebras can bring online.

Concretely, in July 2026:

• You cannot pick “Sol on Cerebras” in the Cursor or Cline model dropdown. It’s not a general API endpoint yet.
• Most Codex users won’t see 750 tok/s. The fast serving is limited-customer; the “up to” ceiling assumes you’re one of the few routed to Cerebras capacity.
• There’s also a regulatory gate: GPT-5.6 is being staggered out under a U.S. government pre-deployment review process, which is part of why the partner list is small. (Anthropic’s Fable 5 hit a related-but-separate government wall in June — see our government-ban resilience piece.)

If you’re evaluating tools today, treat Cerebras-Sol as a preview of where agentic coding latency is heading, not something you can wire into your stack this week.

The local angle: you can already have fast, today

Here’s the twist worth sitting with. If sheer speed is your goal — not frontier quality — you don’t need a wafer in a data center. A capable local model running on your own GPU already streams faster than a GPU-served frontier model, because it’s smaller and it’s the only thing on the card.

A 30B-class coding model on an RTX 5090 or dual-3090 rig streams in roughly the 40–100 tok/s band — comparable to a cloud GPU frontier model, at $0 marginal cost and full privacy. You won’t hit 750 tok/s locally (that takes wafer-scale silicon), but you also won’t pay $30/M output or wait for a partner invite. For the “write this file, iterate fast, keep it private” loop, local inference is the speed play that’s actually available in July 2026.

If that’s the path you want, our sister site runaihome.com has the hardware math: see best local AI models by VRAM and the GPU buying guide for local AI. For wiring a local model into a coding agent, our Ollama context-length fix and OpenCode + Ollama setup cover the traps. And if you’re weighing a fully open-source terminal agent instead of Codex, aifoss.dev tracks the FOSS options.

Where it breaks

No fence-sitting — here’s the honest ledger.

• “Up to 750” is a ceiling. Peak throughput under ideal load isn’t what you’ll see under contention. Expect real sessions well below the headline.
• Speed ≠ correctness. Sol is the same model at any speed. A wrong patch delivered in 7 seconds is still a wrong patch — you review it either way, and review time doesn’t shrink.
• The bill is unchanged. If Sol’s $5/$30 pricing didn’t make sense for your workload at GPU speed, Cerebras doesn’t fix that. It arguably worsens it by encouraging more attempts.
• Availability is the real blocker. Limited partners + government staging + wafer scarcity means “when GA?” has no committed date beyond “coming weeks.”
• Context and modality caveats. Wafer-served deployments have historically carried different context or feature limits than the GPU version. Verify context window and tool support against OpenAI’s docs before you assume parity.

FAQ

Can I use GPT-5.6 Sol at 750 tok/s in Cursor or Cline right now? No. As of July 8, 2026 it’s a limited Codex/API preview for select partners. It isn’t a general endpoint, so it won’t appear in Cursor or Cline model pickers. Broader availability is promised “in the coming weeks” without a firm date.

Does the Cerebras version cost more than the GPU version? No — same Sol pricing, $5/M input and $30/M output. Cerebras changes delivery speed, not per-token price. If anything, faster iteration can raise your total spend by fitting more attempts into an hour.

Is 750 tok/s actually 10× faster coding? Only for generation-heavy work. Agentic loops spend most of their time on reasoning and tool round-trips (test runs, file reads), which the token speed doesn’t touch. Expect a big win on long single generations, a modest one end-to-end.

How does this compare to GPT-5.3-Codex-Spark? Codex-Spark (Feb 2026) was a smaller coding-tuned model hitting 1,000+ tok/s on the same Cerebras hardware, available to ChatGPT Pro in the Codex app/CLI/VS Code. Sol on Cerebras applies the wafer-scale approach to a full frontier model — higher quality, lower peak speed, tighter access.

What should I actually do in July 2026? Nothing structural. Keep your flat-rate Cursor Pro or Codex-via-Plus setup. If low latency matters most, a local model on your own GPU already streams at cloud-GPU speed today with zero per-token cost. Revisit Sol-on-Cerebras when it reaches general availability.

Sources

• OpenAI — Previewing GPT-5.6 Sol: a next-generation model (previewed June 26, 2026; API/Codex partner preview)
• OpenAI — Introducing GPT-5.3-Codex-Spark (1,000+ tok/s on Cerebras, Feb 12, 2026)
• Value Add Pulse — Cerebras Runs OpenAI GPT-5.6 Sol at 750 Tokens per Second (750 tok/s vs 40–120 tok/s GPU baseline)
• WinCentral — OpenAI Unveils GPT-5.6 Sol With Vision AI and 750 Tokens/Second on Cerebras
• ServeTheHome — OpenAI GPT-5.3-Codex-Spark Now Running at 1K Tokens Per Second on Cerebras
• Cerebras — Introducing OpenAI GPT-5.3-Codex-Spark Powered by Cerebras
• DataCamp — GPT-5.6 Sol, Terra, and Luna: OpenAI’s Next-Gen Model Family (tier pricing, Ultra Mode)

Last verified: July 8, 2026, against OpenAI’s GPT-5.6 Sol preview announcement, the GPT-5.3-Codex-Spark launch, and independent reporting on the Cerebras serving speed. Preview access and rollout timing change fast — confirm current availability on OpenAI’s official pages before making a purchase decision.