OpenAI Aurora Models: What the API Leak Shows and Doesn't

OpenAI's aurora models are three unannounced model IDs, aurora-red-alpha, aurora-green-alpha and aurora-blue-alpha, that showed up in OpenAI's API on October 17, 2026. There was no blog post, no documentation and no price. Within hours, testers linked them to anonymous image models in blind arena tests, and some guessed GPT Image 3. OpenAI hasn't said a word, so most of what you've read is guesswork.

Key Takeaways

• Three model IDs appeared in OpenAI's API model list on October 17, 2026, all created within about two minutes.
• OpenAI hasn't announced, documented or priced them, and its changelog and models page don't mention them.
• Reports conflict on whether they're still listed. One account says they were pulled shortly after, another saw them a day later.
• The leading theory is that they're image models, possibly GPT Image 3, based on blind arena tests. That's a guess, not a fact.
• For engineering teams, the lesson is simple: never put an undocumented model on a production path.

OpenAI Aurora Models at a Glance

Claim	Status	Source
Three aurora IDs were in OpenAI's model list	Confirmed	CellCog's authenticated model-list read
Created on October 17, 01:13 to 01:15 UTC	Confirmed	OpenAI's model records, via CellCog
OpenAI has documented or priced them	No	OpenAI changelog and models page
aurora-red-alpha returned capacity errors	Reported by one tester	X posts
The IDs were removed shortly after	Reported, disputed	TestingCatalog
They are image models, possibly GPT Image 3	Unconfirmed theory	Arena tests, Lumina Bench

What Appeared in OpenAI's API

OpenAI's models endpoint lists every model an account can call. On October 18, CellCog reported that its authenticated call returned 144 models, three of them new:

Model ID	Created (UTC)	Owner
aurora-blue-alpha	October 17, 01:13:49	system
aurora-green-alpha	October 17, 01:13:55	system
aurora-red-alpha	October 17, 01:15:26	system

The owner field reads "system," the same as OpenAI's own models, and none has a shutdown date. All three were made within two minutes of each other. That points to one release with three versions, set up in a single batch by someone at OpenAI, rather than three unrelated tests that happened to land on the same night.

That's it. CellCog listed the models but didn't use them, so it couldn't say what they do, how fast they are or what they'd cost to run at any real volume.

How the OpenAI Aurora Models Surfaced

The models sat in the list for about a day before anyone noticed. Here's the timeline as reported:

• October 17, 01:13 UTC: the three IDs are created in OpenAI's API.
• October 18, about 02:59 UTC: the account @scaling01 posts on X that the models just appeared in the API.
• About 15 minutes later: Andrew Curran posts that three mysterious models showed up. His post passes 30,000 views.
• Later that day: TestingCatalog reports the references were removed shortly after, and that anonymous image models appeared in blind arena tests within hours.

One tester also reported that aurora-red-alpha returned 503 capacity errors rather than 404 "not found" errors. If that's right, the model was hooked up to real servers that were too busy to answer. It wasn't just a name in a list. The other two reportedly returned 404s.

How Developers Spot New Models

You might wonder how anyone noticed three names in a list. It's easier than it sounds.

Here's how. Every OpenAI account can ask the API for its list of models. Each entry has a name, a "created" time and an owner. Some developers and newsletter writers check that list every day and compare it with the day before. When a new name shows up, they post it.

That's why stealth models get found so fast. A lab can hide a model from its website and its docs, but if the model is in the API list, anyone with a key can see it. The aurora names sat there for about a day before someone looked.

Were the Aurora Models Pulled From the API?

Reports don't agree. TestingCatalog, citing an alert from a developer Discord server, said the references were removed shortly after appearing, which looked like an accidental rollout. CellCog, on the other hand, said all three were still in its model list when it checked on October 18.

Both can be true. Model lists can differ between accounts and change by the hour, and a quick rollback may not reach every account at the same moment, especially if the change was pulled in a hurry. For builders, the point is simple: you can't count on these names being there tomorrow.

Are the Aurora Models Image Models?

The strongest clue came from outside the API. Within hours of the sighting, TestingCatalog reported that new anonymous models were generating images in blind tests on Arena, the public site where people vote between two unnamed models.

• Samples: the Lumina Bench account shared two cat portraits it attributed to aurora-red-alpha and aurora-green-alpha, which is the only public output anyone has tied to these names so far.
• Speed and quality: red was reportedly faster but lower quality, while green was slower but looked better.
• Blue: hadn't been seen in any public test at the time of writing.
• The guess: Lumina Bench said all three look like image models, probably GPT Image 3. TestingCatalog leaned the same way but called it a guess.

Two cat pictures can't tell you much. TestingCatalog itself said none of the samples looked very impressive. The red, green and blue names could fit a range from fast to high quality, which is common for image models. But that's a pattern, not proof.

What OpenAI's Image Models Offer Today

If aurora is a new image model, it would follow a recent release. According to TestingCatalog, OpenAI shipped ChatGPT Images 2.5 with two API models:

• GPT-Image-2.5 Flare, tuned for speed.
• GPT-Image-2.5 Sunburst, tuned for precision.

The same technology now powers virtual try-ons in ChatGPT shopping. A three-tier aurora family would extend that pattern of offering speed and quality options side by side. It's also why the name is uncertain: after a 2.5 release, the next one might be called 3, or something else entirely.

The Coding Model Theory and the Earlier Aurora Alpha

This isn't the first "Aurora" in AI circles. On February 9, 2026, OpenRouter listed a cloaked model called Aurora Alpha, described as a reasoning model designed for speed, with a 128,000 token context window and no named maker.

Three days later, OpenAI announced GPT-5.3-Codex-Spark, a very fast coding model served on Cerebras hardware that OpenAI said could exceed 1,000 tokens per second. Many people assumed the two were the same. Neither OpenAI nor OpenRouter has ever confirmed it.

So some read the new aurora IDs as fast coding models too. The evidence for that is thin. The name is the only link, Codex-Spark has since been retired according to OrcaRouter's timeline, and the arena sightings point to images rather than code.

What Blind Tests Can and Can't Tell You

Arena-style tests are useful, but they have limits worth knowing before you read too much into them:

• They measure taste, not fit. People vote on which output they like. That doesn't tell you if a model follows your brand rules or your product specs.
• Prompts are random. Testers type whatever they want, so results may not match your use case at all.
• Samples are small early on. A few shared images, like the cat portraits here, say very little.
• Stealth versions change. The model in a blind test is often not the one that ships.

So treat early arena buzz as a signal that something is coming, not as a review of how good it will be. The real review starts when the model ships with a name, a price and docs you can check.

Why AI Labs Test Models in Secret

Stealth testing is normal, and OpenAI has done it before in ways that later became public:

• gpt2-chatbot, 2024: anonymous "gpt2-chatbot" models on the LMSYS Chatbot Arena drew huge attention in spring 2024. When GPT-4o launched in May, OpenAI confirmed that one of them, im-also-a-good-gpt2-chatbot, was GPT-4o.
• Quasar Alpha, 2025: a cloaked model on OpenRouter in April 2025 turned out to be an early checkpoint of GPT-4.1, as OpenAI confirmed at launch.
• Other labs too: Google's image model nicknamed "nano-banana" topped blind image tests in August 2025 before Google revealed it as Gemini 2.5 Flash Image. Stealth image testing is now a common step before launch.

Labs do this to get honest feedback. In a blind test, people vote without knowing the brand. That's honest feedback. It also lets a lab see how a model copes with real traffic before launch.

The catch for everyone else is that stealth names rarely match launch names, and stealth versions often change before release. Our pieces on the GPT-5.6 soft launch and Gemini 4 Pro leaks show how leaked details tend to shift by launch day.

What the Aurora Models Mean for Teams Building on OpenAI

For now, nothing changes in production. But the episode is a good reminder of how to handle surprise models:

• Don't build on undocumented IDs. A model with no docs, no price and no access rules can be renamed, repriced or pulled at any time.
• Don't trust names. Stealth IDs almost never survive to launch, so code that hard-codes them will break.
• Test in a sandbox only. If you try one, keep it away from customer data and production paths, and log what it returns.
• Wait for two signals. A changelog entry plus a price, or docs plus outside tests, is a fair bar before you plan around a new model.

The same rule applies to quieter changes. We recently covered how DeepSeek swapped new weights behind the same API name. The fix is the same either way. Pin versions, test before you switch and keep a fallback.

Questions to Ask Before Adopting Any New OpenAI Model

When aurora, or any new model, does launch, run through these before you switch:

• Is it documented? Look for a models page entry, a changelog note and clear limits on rate, size and use, because a model without those can't be planned around safely.
• What does it cost per task? Price per token or per image is only a start, because a cheaper model that needs three tries to get a usable image can cost more than a pricier one that gets it right first time.
• How long will it be supported? Check for a stated retirement policy and notice period.
• Does it change data use? Read the terms for training, retention and where data is processed.
• Is there a fallback? Plan one.

Can't answer most of these? Then it's too early to move real traffic.

How to Monitor Model Lists Safely

If new models matter to your work, you don't need to wait for X posts. A small daily job can compare your provider's model list with yesterday's and alert you to changes. Here's a minimal version using OpenAI's official Python SDK:

import json
from pathlib import Path
from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY from the environment
today = sorted(model.id for model in client.models.list())

state = Path("models_seen.json")
seen = set(json.loads(state.read_text())) if state.exists() else set()

added = [m for m in today if m not in seen]
removed = [m for m in seen if m not in today]
if added or removed:
    print("Added:", added)
    print("Removed:", removed)

state.write_text(json.dumps(today))

What should happen when the alert fires? Someone reads the provider's changelog, notes the new name in a shared doc and decides whether it's worth a sandbox test. That's it.

Treat the alert as news, not as a green light. When a new ID appears, the right next step is to read the changelog, not to point traffic at it. And keep the API key in your environment or a secrets manager, never in the script.

If You Use OpenAI Image Models Today

You don't need to wait for aurora to plan ahead. If your team already uses OpenAI's image models, a few steps now will make any switch faster:

• Save your best prompts with the images they produced, so you have a baseline to compare against.
• Track cost and time per image on your current model, at the quality level you actually use.
• Note your failure cases, such as text in images, hands, logos or product colors, and test those first on anything new.
• Keep the model name in config, not hard-coded, so you can try a new one with a single change.
• Set a review budget. Decide in advance how many hours your team will spend testing a new model, so a launch doesn't take over a sprint.

When a new model ships, you'll be able to tell in a day whether it's worth moving.

How to Evaluate a New Image Model When It Ships

If aurora does turn out to be OpenAI's next image model, here's how we'd test it before switching:

• Use your own prompts. Collect 50 to 100 real prompts from your product or campaigns, not generic test prompts.
• Compare tiers. If it ships in speed and quality versions, score both on the same prompts.
• Check text and brand details. Look closely at logos, product shapes and any text in the image, where image models often slip.
• Time it and price it. Measure seconds per image and cost per usable image, not just per request.
• Review the rules. Check usage policies, content limits and how generated images can be used commercially.

Our guide to AI agent evaluation covers how to turn a vendor launch into a fair test on your own data.

What to Watch Next for the Aurora Models

• An OpenAI changelog or blog entry naming any aurora model, or a new image model.
• Prices or rate limits appearing for the three IDs.
• More arena samples, especially from aurora-blue-alpha.
• Whether OpenRouter lists them, or finally says what its Aurora Alpha was.

We'll update this post when OpenAI publishes anything official, whether that's a name, a price or a quiet removal of all three IDs.

OpenAI Aurora Models: Our Take

The aurora sighting is real: three undocumented models sat in OpenAI's API, created minutes apart, and something at OpenAI was clearly being tested. The image-model theory is reasonable, given the arena samples and OpenAI's recent image releases. But it's still a theory, and so are the guesses about GPT Image 3 or a launch date.

For teams that build on AI, the useful takeaway isn't the name. It's the habit. Watch model lists so surprises don't catch you off guard, but only build on models with docs, prices and your own test results behind them. When the real launch comes, with a name and a price, that's the moment to test it properly.

How Van Data Team Helps Teams Stay Ahead of Model Changes

We help companies keep their AI systems stable as models appear, change and retire. That means monitoring provider changes, building test sets from your real work, pinning versions and setting up routing so you can adopt a new model on your terms.

If you want a calmer way to handle the next surprise launch, our model portability lesson and AI governance guide are good places to start.