What's confusing to me in addition to the naming is that there are no published guidelines I can use, as far as I can see. Put yourself in the user's shoes. On what basis should one pick a model for a given task?

I can understand smaller models being dumber and faster. That aligns well with scenarios where you are willing to compromise; e.g. you're classifying content or asking a model to format text into a table.

But when you want "maximum intelligence, cost and time be damned", there's the implication that bigger models are smarter on a linear scale, and every provider's model release naming is currently conflicting with that expectation.

This isn't just a naming problem, but a communication problem. If I knew that Astra was the best at coding but a bit bad at writing, and Sol was almost as smart but better at technical writing, then that's the kind of thing I expect to be documented.

One possible way: A simple matrix with horizontal columns like "writing", "coding", "math", rows are the models, and each box is a number of stars from 1-5.

Instead, this sort of thing becomes lore, shared by word of mouth.

Thanks. I think the very response you wrote here is a better form of marketing for the software engineers than what openAI puts out there. When everything is groundbreaking and everything tops charts, nothing is.

I suspect a lot of target demographic (developers) prefer simpler and honest communication about not just the models high points but low points too. With the linked Terra post, if I saw 1 chart that clearly highlighted the usecases for which Terra is _worse_ than higher tier models, I would be more convinced overall.

Everything trying to occupy the top spot in my brain's limited "top model" representation space is not helpful.

Terra and Luna are dirt cheap and good enough for 50% (or more) of the typical junior dev's workload, and great for routine work. Sol and Astra have so much written about them at this point that it should be obvious what those are good at. The large/gigantic models for things that need full intelligence and slightly more branching thinking.

- Understanding how effort and class interact (Is a high effort terra above a low effort Sol? Are larger models mostly always better regardless of effort?)

- understanding when (if ever) a new model tends to be better than an older but higher class one. Is an old astra better than a new terra?

If increasing effort and increasing model class produce improved results in a different way, I miss making it explicit in which way. In other words: What kind of issue warrants going up in effort? what kind of issue warrants going up in model class? What kind of issue is unlikely to be solved by either?

Personally, I pretty much exclusively use claude for coding work (sorry!). Our application is running almost 100% on OpenAI API (except for some fallback models). It is the best API on the market. The models are excellent particularly for any application that is cost sensitive.

That could solve the 'more IQ' problem, because you'd actually have different dimensions (e.g. for 'raw intelligence', technical writing, emotional understanding, etc) that you could use to communicate the differences in models better.

(Of course people would instantly start complaining that the benchmarks numbers are probably fake etc, but it is what it is.)

> Despite that complexity, much of the variation in performance is explained by just a single variable: model size.

please release model size :p

Ted,

I'm assuming you're not in the OAI marketing dept because leading with a simple thumbnail like "Luna < Terra < Sol < Astra" is helpful framing and dropping next-level bombs like:

> "Terra is probably better than Astra and Sol at technical communication, similar on vision and computer use (but much faster!), and a bit worse on most other things. For API developers, it's a nice midrange option if you want something cheaper than Sol but a lot smarter than Luna (especially for vision / computer use / communication). For subscribers, it's not a bombshell release - if you're hitting usage limits, maybe it helps you go a bit further, and if you want clearer communication or faster computer use, it can be a nice option to select."

Is just far too clear and useful! I'm kidding... but it's funny because it's a little bit true.

> Our intention is to make things clear and simple

Your post is the single best product marketing communication I've ever seen from OAI. Serious suggestion: maybe just say something like that on the website. Not buried in a blog post but above the fold.

I'm not the one you were talking with but catching you is godsend since I just ran into a lot of confusion on the naming myself. I think some of it has to do with how they are labeled in the app.

I think simple numbers in naming is great, even 6.1 is fine bc I understand that if I want the latest model, I just need to look for the biggest number. Where I got confused is in the "work" tab, I saw 'Astra' is set as the default. I see the label for it is:

"Frontier intelligence for your most demanding tasks."

To me that reads "this is the 'best' model." Then I see Sol-6.1 which is labeled:

"For coding and every day work."

Then Terra-6.1 is:

"Terra 6.1 Codex Model" (tbh this one might be the most confusing, I'm aware of codex the product but Sol is the one labeled good at coding)

From my POV as a basic plan-based user wanting to do something like...

> design a robust event-driven system, here's the details [...]

I honestly have no idea which one I should use.

Would Astra-6 produce a better design than Sol-6.1? Is the '.1' a big step up from Sol-6? (I'm guessing no but I truly have no idea). I would assume the answer is Astra-6 would produce the best one, even though the labels don't imply it is necessarily geared towards coding?

But tbh the "default" seems to always work for me... and after reading your comment, typing this one out, being forced to think about it... it doesn't seem too bad given your challenges in communicating the purposes of each model and wide audience of consumers. I'm also sure anyone could find a million problems with decisions I've made in software I've built so I try to not be too harsh :)

<version>-<size>

Where <version>: 6.0, 6.1, etc., and <size>: xs | sm | md | lg

E.g. 6.1 Terra = 6.1-sm

If you eventually make specializations like "math" and "jokes" then I would call it something like 6.1-jokes-sm.

We're probably headed to further specialized agents where a single ordering or even model size won't mean a lot.

I.e. are all version numbers independent and Model X 7.5 is not necessarily of the same generation or cut off as Model Y 7.5? Or do all of your 6.1 models have something in common - cut off data, generation, baseline technology, approach, architecture, or something else?

Thanks! :)

With an optional flash mode.

Then as you release models, you pick the model and thinking level that you believe is pareto optimal for cost/performance.

So this auto updates each release, like Terra was probably off this list entirely, but maybe this would appear now in Auto medium or something like that.

I know from looking at charts that each model seems to have sweet spots (like I always use this model in this thinking level and if i want to go cheaper i go here). If you picked those for us, it would be interesting. I do think you should keep the model families for those wanting more consistent experiences, but for many devs they may want to just pick auto something and have it update over time. I think nice if it actually just said in parenthesis what it was, something like: Auto Medium (Terra 6.1 High)

I am not sure if everyone would agree here though. I'm obivously advocating for more naming schemes, and i understand the irony.

It’s probably just unavoidable. Like when Apple release a new MacBook Air first and it is (in some ways) faster than the old MacBook Pro.

I think the planets thing is a bit confusing though. I hadn’t really thought about it being based on the size of the planet. I assumed it was based on how far away they were with terra therefore being the base one.

>If you have suggestions on how to name our products better......

Too late for that. I hope you guys can at least stick to these naming scheme for at least another 2-3 years going forward. Not everyone follows AI / LLM intensely, and it seems there is a new naming changes every year or so.

At least conceptually OpenAI's naming is easier to understand than Claude.

It terms of capability, it would be great to make it clear somewhere that this is 6.1 Model "+" technical communication, vision and computer use improvements. So that at least we know what we should try with these new release and choose a better model for certain workload.

Right now, other than pricing, it is confusing as hell. And in hindsight I wonder if there are fatigue in choosing one people just go with Open Model and stick with it if it is good enough.

Is this really so/could you give a rough example please? I've not used a lot of Claude or ChatGPT, but 3.1 Pro always feels most grounded and intelligent. 3.8 Flash (in my very limited testing) isn't bad, but it feels less nuanced.

(Fwiw I don't use it for code, but ask maths and real world logic based questions.)

You have Luna, Terra, Sol and Astra, each with 4+ reasoning levels. That's ~20 options to choose from.

On a repetitive task like customer support or something, where you have decent benchmarks, you can plot cost versus performance, but you can't really do that on coding.

Maybe stop using version numbers then and just name models like you'd name children.

Medium v10 vs Big v2 makes it look weird and confusing. Especially when there are a sea of influencers and twitters with vibe assessments who will tell you new models best olds models.

Can’t you just start at the top or bottom.

Release new big for paying customers -> release new medium for paying customers -> release new small for everyone

Rinse and repeat. We’d all be much happier

I'm just worried the system design won't be as good if I choose a lesser model so to speak.

Edit: typos/grammar

This seems like one of those cases, where CalVer would be appropriate, and you likely have ideas what you aim for while training, so technical model names (ids?) could include aliases to most things you said. Like 2026q4-xlarge-researcher, 2026q4-medium-humanitarian, 2026q4-medium-coder, 2027q1-small-analyst etc.

> If you have suggestions on how to name our products better, I'm all ears. Our intention is to make things clear and simple, even if we miss the mark sometimes.

How about naming the models:

"Small", "Medium", "Large" and "Very Large"

Or refer to them by parameter count like other companies (e.g. this is 6.1 5T)

If I have a clothing store, and rather than name the clothes sizes Small, Medium and Large I decide to call them Urgon, Planfar and Fangor I shouldn't be surprised if people think my size naming is confusing or silly. And IMO it's not a great explanation to say "oh it's easy, if you are skinny then you should get Urgon, but then if you are a bit more of a medium build you should get a Planfar, but if you want something a bit baggier than Fangor will really work out for you"

Of course we have far too many benchmarks (of questionable utility), but it would be helpful to get OpenAI's take on where it slots in, and how the landscape changes as these get rolled out.

Well you definitely missed that mark extremely badly here.

Have a model alias called "math", another "jokes". Quality labels/date suffixes to these obvious labels. Repoint as needed.

Something for people who don't want to play the cute "which part of the solar system is trending this week" game.

I don't expect the vast majority of your users care. I would guess they want a rough proxy for "cost" and will assume cost=>capability are roughly linked in a linear fashion.

it is very possible that the users weighted by spend do, and I'm therefore simply wrong. But, 2c

Also, I think the naming is great. Like you said, Anthropic faces the same issues you do. Opus is much better at Fable in a lot of stuff without being quite as huge or as smart.

Congrats on the launch.

Versions are good for backend but when communicating I want 2 or 3 levels of detail.

Class_Generation_Modifier

Astra_8_Fast

That's it.

This means: Class - Tells me what it can do, how well. Generation X end of life is ~18 months. Modifier: Variation of options.

And the modifier can be dropped if you add more classes.

Tiny/2026-11. Medium/2026-6. Big/2026-10. XL/2026-01. It may not be sexy, but people know exactly what it is and what to use.

GPT 6.1 X > GPT 6.0 X GPT Y Astra > GPT Y Sol > GPT Y Terra > GPT Y Luna

This order is very important.

Instead, we got Opus 5.5, Sonnet 5.5 and Haiku 5.5 released weeks apart, and so are Sol 6.1 and Terra 6.1?

Terra 2026.2

Hire an actual marketing person instead of letting engineers / ML researchers do things they're clearly terrible at ?

it's almost like ya'll let the AI name it ;)

That is false, considering Astra and Luna don't even exist for 6.1. Terra didn't exist for 6.1 until yesterday. You don't get to make up imaginary tiers. The inconsistency wrt their availability, starting with day 1 of a new model version, is precisely the problem. OpenAI is a user-hostile joke of a firm that users would do well to abandon.

You certainly know that it happened not by accident that traditional computers are producing reliable results, a lot of work went into this.

Computers must produce reliable results, they are simply not useful if not.

People will understand that at some point, but a lot of damage already has been done.

For some reason, this is just hilarious to me. Idk if you're being serious or if this is passive aggressive but the thought of OAI actually taking advice from a random HNer and basing their naming scheme off that is peak.