Codex Spark Alternative: 7 Best Replacements in 2026

GPT-5.3-Codex-Spark was retired on September 14, 2026. Compare the 7 best Codex Spark alternatives, from GPT-5.6 Sol to DeepSeek's near-free API.

21 sept. 2026

OpenAI retired GPT-5.3-Codex-Spark on September 14, 2026, pulling the research preview from the ChatGPT desktop app, the Codex CLI, and the IDE extension in one sweep. Seven months of "the fastest coding model available" ended with a four-line changelog entry, and the most-asked question in the developer corners of the internet this week is the one a Reddit thread sums up best: "Best replacement with Codex 5.3, now gone?" If you had Spark wired into your workflow — your CLI config, your custom agents, your scripts — you woke up to a model that no longer routes.

This post answers that question the way the search results currently do not: a timeline of what actually happened, a comparison table of the seven replacements worth considering, per-model prices and access instructions, the Spark-vs-Sol comparison, and a short migration checklist. Spoiler from the pricing section: the cheapest route to Spark-style responsiveness is not a subscription at all — it is DeepSeek's API at a fraction of a cent per task.

Quick answer: the best Codex Spark alternative by scenario

You want to stay in Codex, zero changes: switch the model picker to GPT-5.6 Sol — it is OpenAI's own recommended landing spot.
You want Spark's speed back: use Fast mode with a supported model — OpenAI's changelog points there explicitly for "faster responses with a supported model."
You want maximum quality and do not mind slower: GPT-6 Astra, added to the Codex model picker on September 9.
You want a cheap flat subscription instead of ChatGPT: OpenCode Go at $10/month or the GLM Coding Plan Lite tier.
You want the cheapest per-token price with no subscription: the DeepSeek API — from $0.15 per million input tokens off-peak, with free browser tools if you do not want to touch a terminal at all.

What happened to Codex Spark?

The lifecycle was short and, by research-preview standards, orderly:

| Date | Event | | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | February 12, 2026 | OpenAI introduces GPT-5.3-Codex-Spark as its "first real-time coding model" — a research preview with 15x faster generation, 128k context, on the order of 1,000+ tokens per second | | September 11, 2026 | OpenAI's Codex team pre-announces the retirement: "Next week we'll be retiring GPT-5.3-Codex-Spark" | | September 14, 2026 | The official changelog marks Spark deprecated; the research preview is "no longer available in the ChatGPT desktop app, Codex CLI, or IDE extension" |

The same changelog entry tells you what OpenAI wants you to do about it: "Switch to one of the recommended models, and update saved configurations, custom agents, and scripts that select gpt-5.3-codex-spark." For the speed use case specifically, it points to Fast mode "for faster responses with a supported model."

Why kill it? OpenAI has not published a detailed rationale, and we will not invent one. The shape of the decision is readable, though: Spark was a research preview — a speed-first experiment that traded roughly sixteen points of SWE-Bench Pro accuracy (about 56 percent, versus the standard GPT-5.3-Codex) for its 15x generation speed. Its job was to answer "what would real-time coding feel like?" Seven months later the answer — Fast mode on a supported model — has been folded back into the main lineup. Meanwhile the lineup itself is churning: GPT-5.5 retires from Codex on October 14, 2026, with OpenAI telling users to switch to GPT-5.6 Sol. If anything, Spark's retirement is a reminder that model names inside Codex are leased, not owned.

Codex Spark replacements at a glance

| Replacement | Cost | What you get | Best for | | ------------------- | ---------------------------------- | ---------------------------------------------------------- | ------------------------------------- | | GPT-5.6 Sol | Included in ChatGPT plans | OpenAI's current recommended Codex model | Staying put with zero reconfiguration | | GPT-6 Astra | Included in ChatGPT plans | Newest frontier model in the Codex picker (and Bedrock) | Maximum quality, speed be damned | | GLM Coding Plan | From $18/mo ($12.60 on yearly) | GLM-5.3 and GLM-5.3-Flash, 10,000 credits per week on Lite | A full subscription at a low price | | MiniMax M3 | ~$0.23/$0.96 per 1M tokens (API) | Fresh M3 model; subscription lineup recently reworked | Budget API tinkerers | | Kimi K3 | ~$1.70/$8.50 per 1M tokens (API) | 2.8T open-weight model built for agentic coding | Open-weight fans, CLI agent users | | OpenCode Go | $10/mo ($5 first month) | Multiple model families inside the OpenCode agent | The cheapest flat subscription | | DeepSeek API | From $0.15/M input, $0.60/M output | 1M-context flash model, pay per token, no subscription | The true free/low-cost path |

Now the details, including how to get each one running.

The 7 best Codex Spark replacements

1. GPT-5.6 Sol — OpenAI's official answer

If you want the boring-but-correct answer: Sol is it. When OpenAI retired GPT-5.5, the changelog instruction was to switch to gpt-5.6-sol — and the Spark deprecation entry defers to the same "recommended models" list. Sol sits in the same model picker Spark did, in the Codex CLI, IDE extension, and desktop app, at no extra cost beyond your ChatGPT plan.

The trade-off is the one Spark existed to paper over: Sol answers at flagship-model speed, not 1,000 tokens per second. For the speed half of the workload, pair Sol with Fast mode, which is OpenAI's own suggested substitute for the Spark experience.

2. GPT-6 Astra — the new flagship

Added to the Codex model picker and Amazon Bedrock catalogs on September 9, 2026 (Codex CLI 0.154.0), Astra is the step-up option when you would rather have the strongest available model than the fastest. If your Spark usage was mostly "quick iterations on small diffs," Astra is overkill. If Spark's accuracy ceiling ever annoyed you — and at roughly sixteen points below standard Codex on SWE-Bench Pro, it annoyed plenty of people — Astra is the correction. Same access path as Sol: pick it in the model picker, update anything that pinned the old model name.

3. GLM Coding Plan — the low-cost full subscription

Z.ai's GLM Coding Plan is the closest "subscription that costs less than ChatGPT" experience, and it was reworked in September 2026 into three tiers (prices per our GLM Coding Plan guide, current as of this month):

| Plan | List price | Usage allowance | | ---- | --------------------------- | --------------------------------------- | | Lite | $18/mo ($12.60 on yearly) | 10,000 credits per week | | Pro | $80/mo ($56 on yearly) | 6x Lite usage, priority model access | | Max | $168/mo ($117.60 on yearly) | 14x Lite usage, dedicated peak capacity |

Every tier runs GLM-5.3 and GLM-5.3-Flash, with requests for older GLM versions auto-routed to the newest — which, after the Spark episode, is exactly the failure mode you want a vendor to design away. Setup means subscribing at z.ai, generating an API key, and pointing your agent at Z.ai's endpoint; the guide above walks the full Claude Code wiring. Z.ai changes pricing often, so verify the current tiers before you subscribe.

4. MiniMax M3 — the budget API

MiniMax shipped M3 and reworked its coding-plan lineup around it. On the API side, M3 runs roughly $0.23 per million input tokens and $0.96 per million output (about $0.05 for cache reads) — comfortably in DeepSeek-style budget territory. On the subscription side, be careful with stale blog posts: the old $10 Starter and $40 Plus-hs tiers are legacy, closed to new subscribers after the rework, so check the current lineup on platform.minimax.io before assuming the $10 price you read somewhere still exists. Access is a standard API key from MiniMax's platform, pluggable into any OpenAI-compatible tooling.

5. Kimi K3 — open-weight and built for agents

Moonshot AI's K3 is a 2.8T-parameter open-weight model whose official positioning is precisely the Codex crowd: agentic coding. Via OpenRouter it lists around $1.70 per million input and $8.50 per million output tokens; Moonshot also sells Kimi Code subscriptions for its CLI agent at prices it positions well below US frontier subscriptions — check kimi.com for current tiers rather than trusting secondhand numbers. For terminal-first developers, K3 is also reachable through aggregators: our OpenCode tutorial shows the Connect flow where Kimi models sit one dropdown away — and our Kimi K3 in Claude Code guide covers the official settings.json route.

6. OpenCode Go — the cheapest flat subscription

OpenCode Go is a $10/month subscription — $5 for your first month — from the team behind the OpenCode terminal agent, with what they describe as the highest rate limits of any of their plans and access to multiple model families. It is the simplest answer to "I paid $0 for Spark inside my ChatGPT plan and I do not want to think about tokens." OpenCode's Zen console also carries genuinely free models — DeepSeek V4 Flash Free among them — so you can run the agent before paying anything. Our OpenCode tutorial covers install to first scaffold in thirteen steps.

7. DeepSeek API — the free and near-free path

Here is the section Spark users should actually read carefully. DeepSeek's API is pay-per-token with prices that make a flat subscription hard to justify for light and medium use ($/1M tokens, per DeepSeek's pricing docs):

| Model | Input (cache miss), off-peak / peak | Output, off-peak / peak | | ----------------- | ----------------------------------- | ----------------------- | | deepseek-flash | $0.15 / $0.30 | $0.60 / $1.20 | | deepseek-v4-pro | $0.66 / $1.32 | $1.98 / $3.96 |

deepseek-flash brings a 1M-token context window — nearly eight times Spark's 128k — and 384K max output. Off-peak pricing (everything outside weekday 01:00–04:00 and 06:00–10:00 UTC) roughly halves the bill, and cache hits cost less still. At these rates, the kind of quick-edit workload Spark was built for costs pennies per day.

Three ways in, from most to least hands-on:

Bring your own agent. Claude Code and most terminal agents accept an Anthropic-compatible endpoint, and DeepSeek documents the swap directly:

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_API_KEY=sk-your-deepseek-key

Our DeepSeek harness setup guide covers the terminal wiring end to end, and using DeepSeek in Cursor covers the editor crowd. One warning that saves an evening: DeepSeek retired its previous model names on July 24, 2026, so use the two above.

Free rides inside other tools. Cline's desktop app (released September 14, the same day Spark died, which is either coincidence or the market responding) includes free access to a DeepSeek flash model, with the ClinePass subscription at $9.99/month for more — our DeepSeek in Cline tutorial walks it. OpenCode's Zen console carries DeepSeek V4 Flash Free as well.
No terminal at all. Our free browser tools run the same models with zero setup: the DeepSeek App Builder for one-shot web apps, the DeepSeek Game Maker for playable games, and Vibe Coding Games when you just want to see what a cheap model can do in ninety seconds.

Codex Spark vs Codex Sol

The comparison most people are actually weighing, condensed:

| | Codex Spark (retired) | GPT-5.6 Sol | | --------- | -------------------------------------------------- | --------------------------------------------- | | Status | Deprecated September 14, 2026 | OpenAI's current recommended Codex model | | Built for | Real-time coding — speed first | General agentic coding — quality first | | Speed | 15x generation, on the order of 1,000+ tokens/sec | Flagship-standard response times | | Accuracy | ~56% SWE-Bench Pro, ~16 points below GPT-5.3-Codex | The model OpenAI migrates users to, not from | | Context | 128k | Codex's standard context for supported models | | Cost | Was included in ChatGPT plans | Included in ChatGPT plans |

Read that table one row at a time and the replacement logic writes itself: Spark was a deliberate speed-for-accuracy trade inside a 128k window, and Sol removes that trade. If your Spark work was rapid UI iteration and small diffs, Fast mode on Sol covers it. If Spark's benchmark gap quietly annoyed you, Sol closes it. What Sol does not change is the platform risk this episode exposed — model names inside a closed platform are revocable at a changelog's notice, which is the strongest argument for keeping a second, API-based workflow warm.

How to switch from Codex Spark

The migration is mostly remembering where you typed the old model name:

Open the Codex model picker (CLI, IDE extension, or desktop app) and select GPT-5.6 Sol — or GPT-6 Astra, or enable Fast mode for the speed lane.
Update saved configurations, custom agents, and scripts that select gpt-5.3-codex-spark — this is the official changelog instruction, and stale references are what produce "model not supported" errors.
Grep your repos for the old name: AGENTS.md files, CI workflows, prompt templates, and dotfiles are the usual hiding places.
If you are switching to DeepSeek instead, set the two environment variables shown above and check the model names — the July 2026 rename means older tutorials will happily hand you dead names.
Re-run one known task as a benchmark before committing — same prompt, same repo, compare the diff quality and latency against your Spark-era baseline.

Budget ten minutes for steps one through three. Budget an evening for step five, because it is the one that tells you whether the replacement is actually good enough.

FAQ

What happened to Codex Spark? OpenAI deprecated GPT-5.3-Codex-Spark on September 14, 2026. Per the official changelog, the research preview is no longer available in the ChatGPT desktop app, Codex CLI, or IDE extension, and users are told to switch to one of the recommended models and update any configuration that selects the old name.

Why did OpenAI discontinue Codex Spark? OpenAI has not published a detailed rationale. What is documented: Spark was a research preview from February 2026, a speed-first experiment that gave up roughly sixteen points of SWE-Bench Pro accuracy for 15x faster generation, and its speed use case now lives in Fast mode on supported models. Take the "folded back into the main lineup" framing as informed reading, not official statement.

Was Codex Spark free? Spark was not a separate purchase — it was a research preview available inside ChatGPT plans, launched as a speed-oriented option for Codex users. What was never free was open-ended usage: Codex usage on ChatGPT plans has always been rate-limited. With Spark retired, your plan cost now buys Sol and Astra instead.

What is the best free Codex Spark alternative? For genuinely free: DeepSeek V4 Flash Free inside OpenCode's Zen console, the free DeepSeek flash model in Cline's desktop app, or our own browser-based tools — the DeepSeek App Builder and DeepSeek Game Maker — which need no signup. For near-free at scale, the DeepSeek API's off-peak pricing starts at $0.15 per million input tokens.

Is Codex Spark coming back? Nothing in OpenAI's changelog or announcements suggests a return; the deprecation entry reads as final, with Fast mode positioned as the successor for speed-sensitive work. Research previews do sometimes reappear as features — the honest position is that no comeback has been announced, and building anything on the expectation of one would be unwise.

Codex Spark or Codex Sol — which should I use now? You cannot use Spark; the question is really whether Sol is enough. For the large majority of Spark use cases — quick edits, small-diff iteration, UI polish — Sol with Fast mode enabled is the direct replacement on the same subscription. If you were exceeding Spark's 128k context or running long agentic sessions, the DeepSeek API's 1M-context flash model at off-peak prices is the more interesting upgrade path.