If you weren’t paying close attention to OpenAI’s developer channels on September 11, you probably missed it entirely. There was no keynote, no blog post with a bold headline. Just a post from Tibo, the Codex lead, dropped casually on social media: GPT-5.3-Codex-Spark is retiring next week.
The reasoning was matter of fact. Usage had been sliding for a while, and the team already had noticeably better models on hand. Time to make room for what’s next, he wrote. Then, almost as an afterthought, he added a jab at his own team: he couldn’t believe they’d ever shipped a model with a name that long.
The comment section didn’t exactly mourn. If anything, there was a sense of relief in the air. One developer, argofowl, put it bluntly: Spark was a fun model and also a pretty terrible one that was basically unusable, and he was glad to see it go since he hadn’t touched it in months. Another developer added that across several sizable projects, he’d barely used it at all, because even basic tasks like understanding project context or parsing logs would blow past its context window almost immediately, forcing him to start a fresh conversation.
The part that actually stung a little wasn’t the model itself, it was the quota that came bundled with it. A well known developer, Chubby, said he wished there was a “GPT-6-Spark,” and the reason was simple: it came with its own separate allowance that didn’t eat into the main quota. With the flagship model Astra’s limits running tight these days, plenty of people had been treating Spark as a backup tank to run on once the main quota dried up. The model’s quality was almost beside the point. That separate pool of capacity was the thing people actually missed.
News of this made its way into Chinese tech media too, with outlets like AIbase and 36Kr both running the story (sources linked at the bottom). The framing wasn’t clickbait: Spark really had been OpenAI’s fastest model at one point, and it went from launch to shutdown in just seven months.
A grand entrance, a quiet exit
Rewind to February 12 of this year. Spark’s launch was a big deal. It was OpenAI’s first model built specifically for real time coding, with a 128k context window and the ability to generate over a thousand tokens per second. According to the official numbers, round trip overhead between client and server dropped by 80 percent, per token processing overhead fell by 30 percent, and time to first token was cut in half. Code stopped trickling out line by line and started arriving in whole blocks at once, which made for a pretty striking demo experience.
The earliest adopters were really excited. Developer Ryan Vogel built it straight into his production workflow: GPT-5.4 handled planning, GPT-5.3-Codex handled the actual construction, and Spark did the legwork of exploring the codebase, checking documentation, and offering a second opinion. He said it was the first time he’d assembled a workflow with zero Claude models in it, and it was both faster and cheaper. Jason Liu, the author of the Instructor library, went even further, spinning up twenty Spark subagents to search a file system in parallel and declaring that RAG was dead. He later joined OpenAI’s Codex team.
Beyond the specific use cases, there was a bigger strategic story underneath Spark’s launch. It was OpenAI’s first production model running outside the Nvidia stack entirely, powered by wafer scale silicon from a startup called Cerebras, the WSE-3. It was also the first delivered answer to a massive commitment: a 750 megawatt, over 20 billion dollar compute deal OpenAI had signed with Cerebras. This wasn’t just another model release. It was a real bet on a hardware path that didn’t run through Nvidia.
But the shine wore off faster than it appeared. Spark’s fatal flaw was structural: a single wafer simply couldn’t fit a full flagship model, so Spark was really a distilled, scaled down version that traded intelligence for raw speed. On the Terminal-Bench 2.0 evaluation, Spark scored just 58.4 percent accuracy, well below the full GPT-5.3-Codex’s 77.3 percent. OpenAI’s own SWE-Bench Pro curves told a similarly unflattering story. Spark could compress task time down to one or two minutes, but its accuracy plateaued somewhere between 47 and 51 percent. The full version, by comparison, started at 51 percent accuracy at the three minute mark, climbed to 56 percent by nine minutes, and reached 57 percent at sixteen minutes. In other words, the minutes Spark saved cost users five to six points of accuracy.
Even the headline “15x faster” claim didn’t hold up under scrutiny. The day after launch, developer Nicholas Van Landschoot published a long thread picking apart OpenAI’s comparison conditions. It turned out the 15x figure came from comparing Spark against a version of GPT-5.3-Codex running at the highest reasoning effort setting. When you normalize for equal accuracy, Spark was only about 1.37x faster. And in real coding scenarios, its weaknesses got amplified: it would fabricate API endpoints that didn’t exist, produce unstable JSON, and derail easily on multi step tasks. One training organization, Turing College, summed it up with a line that stuck: speed without intelligence is just failing faster. For anyone actually shipping code, waiting seventeen minutes for something that works will always beat getting a buggy mess back in two.
What actually killed it was the company’s own next generation tech
If Spark had simply lost out to the full flagship model on accuracy, that would just be the usual speed for quality tradeoff, nothing particularly newsworthy. What actually signed its death warrant was something Cerebras announced on August 13: Ultrafast mode.
This time, what ran on the wafer wasn’t a shrunken version of anything. It was the actual flagship model, GPT-5.6 Sol, running at full strength. By slicing the massive flagship model into layers and pipelining it across multiple CS-3 nodes, Ultrafast mode hit 750 tokens per second while maintaining, in Cerebras’s words, “the same intelligence as the standard version.” Cerebras’s own comparison put Ultrafast at 14 times faster than the standard tier, with a middle tier called Priority landing at 2.5 times faster. Cerebras CEO Andrew Feldman put it in one blunt sentence: speed and intelligence are no longer mutually exclusive.
They backed this up with a timing comparison across six quality matched tasks from GDP-Val. The standard tier Sol took an average of 7.7 minutes per task, with 7.5 of those minutes spent on generation. On Ultrafast, the same task took a total of 83 seconds, with 68 seconds on generation and about 15 seconds of non reasoning overhead like tool calls. End to end, that’s a 5.6x speedup, with essentially no drop in answer quality.
That single result didn’t just announce a technical breakthrough, it drained Spark of any remaining reason to exist. Spark’s entire premise was trading intelligence for speed, and barely half a year later, the same company running the same wafers could deliver a full flagship model at only a quarter of the slowdown, with none of the lost capability. Cerebras’s manufacturing capacity is finite. When an unwanted scaled down model and a flagship version everyone is scrambling to use are competing for the same wafers, it’s obvious who has to make room.
Spark wasn’t the only piece of legacy baggage getting cleaned out. Over the past three months, OpenAI’s model lineup has been going through a fairly aggressive turnover. On June 2, GPT-5.2 and GPT-5.3-Codex were retired. On August 31, GPT-5.4 and 5.4 Mini were retired, with users migrated wholesale to the 5.6 generation. On September 11, it was Spark’s turn. Alongside this old generation exit, Codex also rolled out a new naming scheme built around Sol (sun), Terra (earth), Luna (moon), and Astra (star). A name like “GPT-5.3-Codex-Spark,” with its long version number and product line suffix, feels like a relic from a previous era at this point.
There’s a deeper shift happening underneath all of this. Speed is transitioning from being its own dedicated model into becoming a tier option baked into the flagship model itself. Just as reasoning effort now ranges from Light to Max, speed at OpenAI is now split into Standard, Priority, and Ultrafast tiers, priced according to how much compute you’re willing to pay for. In hindsight, Spark did exactly what it was supposed to do. As a transitional pathfinder, it proved that Cerebras’s wafers could handle production grade generative AI traffic, and it proved inference workloads could run entirely outside the Nvidia ecosystem. Once the path was proven and the main force moved in, the pathfinder’s job was simply done.
Seven months is the number worth sitting with
If you’re only reading this as a bit of tech gossip, you could stop here. But that seven month number deserves a longer look.
A product that carried real strategic weight, had a clear technical differentiator, and represented real investment in R&D and compute went from launch to complete shutdown in seven months. And it wasn’t market competition that killed it. It was murdered by its own sibling, next generation technology from the same company released just months later. This isn’t a story about failure. It’s a story about the normal pace of iteration accelerating to a point that feels almost violent.
For the average user, the direct impact of this news is probably small, since most people never used Spark in the first place. But the pattern it reveals is already quietly shaping everyone who uses AI tools. Whatever AI product you’re relying on today, whether it’s a coding assistant, an image generation model, or some vertical specific agent, its lifecycle may be compressing far faster than you’d expect. Software used to have a lifecycle measured in years. Some AI models and features now have lifecycles measured in quarters, sometimes months.
There’s a mechanism behind this that’s easy to overlook. Competition among AI companies isn’t purely about who builds the smartest model anymore, it’s about who can push the underlying hardware to its absolute limit. When the underlying hardware itself, whether that’s Nvidia GPUs or Cerebras wafers, is iterating rapidly, and the capability achievable on the same compute doubles within six months, then any product design built around “today’s hardware ceiling” carries an inherent expiration date. Spark’s cause of death, stated plainly, is that the moment it was born, its eventual retirement at the next hardware leap was already baked in. Nobody could have said exactly when, but the outcome was never really in question.
What to actually do about this new normal
Start with developers. If you’ve already woven a specific AI model or API deeply into your workflow, your product architecture, or even your business logic, Spark’s retirement process is worth studying as a reference case. A few signals are worth watching for: did the provider give a clear migration path (in this case, OpenAI moved everyone to the 5.6 generation, no cliff edge involved), did they give a reasonable transition window (a week’s notice isn’t generous, but it’s still a heads up rather than an instant shutoff), and does a superior replacement already exist (Ultrafast mode had already closed that door, so there was zero upside to sticking with Spark).
The practical countermeasures aren’t complicated, but they do require building the habit. First, avoid hardcoding your architecture to a specific model version, wrap model calls in an abstraction layer so swapping the underlying model requires minimal changes. Second, keep an eye on usage trends and vendor announcements for the models you depend on regularly, rather than scrambling only after a shutdown notice lands in your inbox. Third, be extra cautious with any product that’s essentially “a specialized small model traded for one particular performance metric.” History keeps repeating the same lesson: specialized models tend to be temporary stopgaps until a flagship model catches up on that specific capability, at which point the specialized model has essentially nowhere left to go.
Now for everyday users. You probably can’t predict which AI tool is going to get retired next, but you can adjust your habits and expectations. Don’t build deep emotional or workflow dependence on any single AI product, especially ones with a smaller niche audience or modest user base. OpenAI’s own stated reason for retiring Spark was straightforward: usage kept declining, and a smaller user base is a real, practical factor in which products get cut first. Regularly back up whatever data, prompt templates, or workflow configurations you’ve built up inside a given AI tool, and don’t assume any of it is permanent.
For businesses, this story is a real risk flag. If some part of your operations depends on a specific vendor’s particular model or a particular pricing tier, especially one that’s cost effective but relatively niche, now is a good time to take stock. If that dependency vanished tomorrow, how long would it take to switch to an alternative, and what would that switch actually cost? If that answer makes you uneasy, building out a backup plan now is far cheaper than scrambling after an actual shutdown notice arrives.
Speed isn’t disappearing, it’s just changing addresses
Spark is gone, but the demand for speed hasn’t gone anywhere. It’s simply moved from being an independent, dedicated model into becoming a paid tier baked into the flagship product. That’s a pattern worth remembering across the AI industry more broadly: a lot of capabilities that once justified an entire standalone product eventually get absorbed into the main product line, reduced to an option, a toggle, a pricing tier. Plenty of the single purpose AI tools we’re all familiar with today will probably follow a similar path in a few years, not because they did anything wrong, but because the large models underneath everything keep absorbing whatever functionality used to require a separate product, folding it in as just one more add on tier.
Sources:
- https://hub.baai.ac.cn/view/57934
- https://www.36kr.com/p/3981223980923651
Related reading
- OpenAI Just Killed the AI Demo Era. Now What?
- ChatGPT Work: OpenAI Agents Now Deliver Finished Work, Not Chat Replies
- ChatGPT Work Is OpenAI Bet That AI Should Deliver Finished Work, Not Just Advice
- Runway GWM Worlds 2 Turns Video Generation Into Something You Can Walk Into
- Giving AI Real Eyes: Fei-Fei Li Atlas Wants Machines to Live Inside 3D Space
Stay updated with our latest AI insights
