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.
Luna < Terra < Sol < Astra, fine. But does Terra 6.1 beat Sol 6? Does Fable 5.1 beat Opus 5.5? If I build something around this Terra 6.1 release, then when Luna 6.2 is released in a month, should I swap?
If they were called iPhone 14 Luna and iPhone 16 Sol then this is less clear.
Or on the flipside, if the models were called GPT 6.1 Mini and GPT 6.1 Max, nobody would be arguing about the names being hard to grok. The words 'mini' or 'small' are more descriptive than 'Luna' or 'Terra'.
If you look back the naming problem started around the point that OpenAI started doing reasoning models (o1, 4o) where they had to describe this fork in model behavior that let a smaller model think longer and be smarter.
You can come up with naming schemes that don't clash, but there's something to be said for this approach where the thinking level is like you describe and the model name requires you to learn that Astra is the largest model.
* Luna (Moon)
* Terra (Earth)
* Sol (Sun)
* Astra (Galaxy/Universe)
The relative sizing seems dead simple.
1. Even more dead simple if it just used Moon instead of Luna, Sun instead of Sol, etc. - one less quick translation in the head.
2. Or even more dead simple if it just used "Small", "Large", etc. - removing another quick translation in the head. (On the other hand, all these suggestions are English - maybe Luna, etc. is more understandable for non-English speakers?)
You're right! The relative sizing of models is dead simple. This doesn't help when there are improvements between release numbers, and models are released one at a time instead of as a family.
When Sol 6.4 comes out and the latest Astra is still 6.1, which do you use?
Or I might try both and pick whichever I prefer for a given task...
Sure, in a hypothetical world where the latest Max phone is two generations older than the latest Mini phone. In which case now you have to evaluate not only screen size but ALSO specs and component age and software support etc. How badly do you need the bigger screen? Etc
If you are comparing the iPhone 16 Max to the iPhone 16 Mini, everything is a lot easier.
I wish
I'll just stick to mostly Sol on low/medium/high and start experimenting with Terra tomorrow onward to see what it does noticeably better than Luna/Deepseek flash.
Any pareto frontier model, especially from the leading labs is guarnateed to be good enough for whatever your expectations are at this point. A quick few day test should be enough for anyone to make their own conclusions.
> Run your own evals then if you have this much of a need to "correctly" choose.
No. OpenAI want my money, it's on them to communicate properly.
I understand how it can be confusing, but I don't think that this is exactly a problem.
Luna through Astra offer qualitative descriptions of the model's size. Presumably OpenAI trains its biggest model (Astra-ish, maybe even larger) first, then distills it to smaller sizes.
Verison numbers reflect something about the architecture or training dataset. Again, they keep these details close to their chest, but we should expect that weight-for-weight higher versions should beat lower versions.
This offers us two axes of 'better', but these axes are also not directly comparable. An earlier but bigger model may or may not beat a newer but smaller model. This is where 'spiky' intelligence comes in.
This is also where calls to 'run your own evaluation' really do start to matter. If you care enough about this performance[1], then you also have specific problems that you care about. No generic benchmark can fully answer that question, hence the need for a specific evaluation.
[1] — And you don't have to! A casual user is probably served reasonably well by anything put out in the past six months. I think Microsoft is still serving GPT-4o under some Copilot branding.
Whether they train the biggest model first or not is not relevant; what matters is what they release. Right now we've got 6.1 Sol and 6.0 Astra. Over at Anthropic they've got Opus 5.5 and Fable 5.1. The existence of a hypothetical Fable 5.5 that I'm not allowed to use doesn't help me.
I wouldn't necessarily say that. Atmospheric mass may be obvious to us, but I suspect it's not nearly as universal knowledge as one may assume.
And I actually assumed at first that they were based on distance from us (terra < luna < sol), so I kept confusing terra and luna.