I work at OpenAI and I can try to explain our logic.
In general, LLM performance is incredibly multidimensional. There's no guarantee of a fixed ordering where the model that is best at math is also the model that's best at jokes. Despite that complexity, much of the variation in performance is explained by just a single variable: model size. In general, models that are bigger will (a) be more performant / reliable, (b) cost more per token, and (c) have better recall of esoteric facts. As you note, our models are ordered:
Luna < Terra < Sol < Astra
Even today, I'd recommend this as a general starting point for picking models. If you care about quality only, pick Astra. If you're a bit price sensitive, pick Sol. If you're very price sensitive, pick Terra or Luna.
Of course, model size doesn't capture all variation. Models that are trained later might have new data or new techniques or new architectures that earlier models lack. You can see this with models from all providers - Sonnet 5.5 outperforms Fable 5.1 in ways, and Gemini 3.8 Flash outperforms 3.1 Pro in ways.
In the case of GPT-6.1 Terra, I'd say Terra is probably better than Astra and Sol at technical communication, similar on vision and computer use (while being faster / cheaper), 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.
If you have suggestions on how to name our products better, I'm all ears. Our intention to make things clear and simple, even if we miss the mark sometimes.
Unfortunately, a lot of the complexity is somewhat irreducible and due to to the actual complexity of the products. Scaling model size is different from scaling reasoning effort which is different from scaling multi-agent count. So if we just swept all of those under a single name of "more IQ", it would make the naming simpler but the experience would be a lot worse, as important details would be obfuscated from end users.
Since internally you probably have a fairly good intuition for what these models do well, what about assembling a benchmark suite (with multiple dimensions) that produces results that show that intuition, but in a 'somewhat objective' way?
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.)
The 4-tier naming is honestly as clear as you can get. I have no idea what people are so confused about.
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.
Appreciate that these things have orthogonal measurements; with that in mind, given that the name signifies size, what does version number signify?
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?
- 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?
Please can I ask about one parameter you didn't mention here? All of your models have both a reasoning effort setting and also a non-pro vs pro setting. I have some intuitive feel (from experimenting) for the difference a larger vs smaller model makes, and why that's different from adjusting reasoning levels, but I have no real feel for how pro vs non-pro is different in behaviour from adjusting effort.
> If you have suggestions on how to name our products better, I'm all ears.
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.
This is one of the last bastions of semi-serious discussion on the internet, and it's full of incredibly high level engineering talent.
Where else would you go? I'm honestly scratching my head thinking of someplace that wouldn't run you out on a rail, but that would give serious feedback. Kernel mailing lists are out, maybe there's something like that which I can't remember off the top of my head, but...
Also, nomenclature is incredibly hard. There are only two hard problems in computer science: cache expiration and naming things.
I don't understand what's so confusing about this.
The lineup of models is still the same.
There are four models: luna, terra, sol, and astra.
Pricing increases for each level. This new 6.1 Terra is 50% cheaper than Sol 6.1.
They are lowering prices for newer releases, so yes if you compare Sol 6.1 to 5.6 Terra it won't look right, but why are you doing that? Look at the same release version for comparable numbers.
Each model improves in successive releases but they maintain pricing and capability coherency within a release version.
Yes, Sol 6.1 is supposed to rival Astra for some work, which is what you'd expect from a later versioned release model against a prior release bigger model.
Assuming they release Astra 6.1 at some point, I expect it'll be better than Sol 6.1, at a higher price.
I don't understand what people are asking for here? No reductions in pricing? Different model names on every version release? Not releasing any models for a version number until they're all ready?
Hey! I think it's confusing because there is a mix of three components:
- Model name
- Version number
- Effort level
All 3 of these are a one-dimensional balance of price/speed, and capability (Loose terms). The confusion is in how these overlap, how they're announced/marketed etc. So you go from 1 dimensions to 3; you can visualize it as a box. For a given task, how do you choose where in this box you select? Which regions are your favorite? Can you map each region of this 3D space to specific tasks? Label them with intuitive names?
Given the operations of the model are opaque, can you see how someone (most people?) might be confused?
But what's the ask? This is the cleanest way I see of them doing it.
I see a ton of criticism and not a single person coming up with anything better, unless it's to take away options, like removing effort level.
What about buying Intel CPUs? A car? Electrical components?
If you're not just using this at a consumer level to ask about cooking recipes (and if that's your use case, you really don't care about API pricing, or any of this, and can just use the default), and are using it professionally, then this seems like a low bar of effort to understand what you're buying.
I do grant you the relationship between model and effort level has an unclear relationship, but there are also tradeoffs in most complex technical products that are not always clear; this is exacerbated by the fact that this product is stochastic.
Why are engineers using this as a professional tool expecting this to be bought like a consumer gadget and then blaming the maker?
Effort (as it's used in the context, how many "thinking" tokens to burn) is still a free variable. It's not always shown to the end user but you can set it independently for any of these models.
After that you just have model "strength" and version number. But of course strength is only comparable at equal version number and the two axes are almost parallel.
Anthropic also does this, perhaps to a lesser extent.
Part of the confusion is that it's not linear capabilities. One model is not strictly "better" than the other. They have orthogonal capabilities.
I think the names are more of a reference to price. Luna is always cheaper than terra which is cheaper than Sol which is cheaper than Astra (for the same model number).
If you daily all these models (and have a modest budget, not some >$400 corporate allowance), then it's pretty obvious that Luna is small and fast, and Sol 6.1 is the big one for jobs that need significantly above average intelligence, comparatively to a human engineer. I use both constantly. Astra is really not relevant for the average dev except to do some moonshot task with a vague verification loop.
Sure Sol 6.1 on low/medium can be considered "cheap" considering its abilities, but it's clearly not meant for the same type of tasks as Luna. You just grow an intuition for when something is solvable with a Luna-sized model. I'm guessing Terra is good for the tasks that you'd typically use Sol 6.1-low for, or for Luna type tasks (or other not-novel problem) where you want to reduce the risks of suboptimal decision making. It's exactly what I'd go with for feature additions where the correct solution is already mostly designed/specced-out.
The way to think of this is that (current) inferencing hardware has natural cut points of efficient scale (assuming some optimal architecture which at this point is almost always an MOE variant), so you always have an incentive to provide 3-4 model sizes (which nicely enough often means diff speed to answer also).
You are also rolling the training of your models by size and the lat est small model can sometimes beat an older model.
For a while we thought you just train the big model first then distill smaller models from it but since we've learnt the importance of on policy RL (basically the way a small model figures out a problem is very diff from a big model so it's best to RL optimize each model distinctly)
If you scale a model down, or switch out attention with linear attention, or introduce KV-compression, etc., you don't really know how it will affect model performance before you've trained the model.
And once you've spent millions training it, you might as well make it available if it's pareto optimal for some tasks. It also gives you more insight seeing how people use it in practice.
But minor credit to Anthropic, at least they've mostly stuck to their four model names (Haiku, Sonnet, Opus, and Fable). You mostly know where a model is MEANT to be positioned from the name alone. OpenAI cannot keep it consistent from release to release.
But, yes, currently Opus Vs. Fable has the same issue as Sol-6.1 Vs. Astra.
Both companies have screwed up their naming royally. Maybe that's intentional - I'm sure it doesn't hurt Anthropic to have people using Fable a bit longer than they need to and racking up a huge bill in the process.
It's like iPhone 17 being faster than iPhone 16 Pro. Because it's newer and benefits from advances in chip architecture, despite being a lower model tier. Sometimes different iPhone models are released at different times.
It's especially confusing because Sol 6.1 is mostly just Astra but 10x slower at 1/10th the price - unless you pay for it to be as fast as Astra - at which point it's the same speed and price...
It's nice that they have Terra which seems to fill a void that's been needed since Sol 6 focused on cost (at the expense of quality), Sol 6.1 got a huge boost in quality, but became unusably slow unless you paid Astra prices - at which point, why not just use Astra?
Wait I always thought terra was the smaller model and the further away you went in space the bigger the model (luna is further away so it’s better than terra)
Can anyone give me the compelling reason for Terra and Sonnet to exist?
Virtually every task I give to either is better served by going up a tier and down a reasoning level, or down a tier and up a reasoning level. I simply don't understand their use case. No testing I've done has shown them to have a niche where there isn't a cheaper-with-equal-results or more-performant-at-same-cost option.
Sonnet is way faster than Opus when doing everyday tasks, I think on the subscription plans it's a better option when you need something done faster than Opus' long thinking sessions.
I think for the majority of the audience here who use these models inside of coding agent harnesses w/ subsidized monthly subscriptions, there likely isn't one. Depending on how Terra contributes to the rate limits, it may make sense to use it for some subset of a repeated workflow to get more mileage out of sub.
If you pay API prices for inference in your product stack & have specific use-cases w/ custom evals, these smaller models provide an additional cost/speed lever to adjust. Ultimately, I think the point is to compete on cost for use-cases where Sol on the lowest reasoning is overkill.
If you have a fairly straightforward usecase where Terra performs just as well as Sol, but is faster and cheaper, why not use it?
If you use API in agent or your own integration with software, such models make a lot of sense. We use Terra 5.6 for "question to SQL" translation for example. It's good enough and affordable enough. Luna will probably not handle complex queries well while Sol is too expensive.
There is a chasm of performance difference between haiku and sonnet ime. Sonnet is cheaper and faster than Opus, so if you're providing a service via api where cost and speed is important, it's a big difference.
On the API we use a lot of Luna (cost efficient) and sometimes Terra level models. I think we never use a larger model. These are models that our app runtimes depend on.
On subscription for coding and stuff I am basically on Astra Ultra all day long.
i use sonnet to generate answers to help-desk tickets, which it does for significantly cheaper and insignificantly worse than opus.
if you're just talking about use in codex or claude code, then sure, leave it on opus all the time. but for running routine api requests, sonnet is great.
Cheap and affordable. Dispatching proper tasks to these models can save you a huge % of your quota. Especially if you _know_ the task is simple (ie add something here or there, or archive a bunch of files and reformat kinda thing)
Maybe it's my tasks, but in the cases you're describing, I'm usually better off going down to Luna. I specifically don't see the gap where "It's too complex for Luna-high" and "It's not complex enough for Sol-low" exists.
I've personally found that most models completely collapse at sub-medium effort. I generally run most of my stuff at medium/xhigh with heavy core tasks @ max
Similar 75% price cut trajectory as GPT-5.6 Sol -> GPT-6.1 Sol. Overall, Terra is still half the price of Sol.
But like the original release of Terra, it's still a weird middle child between the small-model-that-got-substantially-better (Luna) and the large-model-that-got-significiantly-cheaper (Sol). The TerminalBench 4.0 cost-per-task results are a bit confusing and I'm not sure why you would pick Terra over Sol in that case. Overall this release seems like a flex on Sonnet 5.5: a model which is having its own middle child problems between the godly Opus 5.5 and the surprisingly capable Haiku 5.5.
Interesting that both "none" and "low" reasoning levels appeared not to spend any reasoning tokens at all, and in fact low ended up using less tokens and costing less than none here.
"medium" did use 496 reasoning tokens, but that's apparently not enough here to return a visible reasoning trace.
It's neat that we can now compare the Terra without reasoning pelican (cost 0.64 cents) with the equivalently priced Luna with reasoning pelicans (Luna xhigh is 0.40 cents, Luna max is 0.91 cents). I think the Terra low one compares favorably to those, though I'd suggest also comparing them on tasks more representative of real work than generating pelican SVGs!
Looks great on the first chart, but terrible on the Terminal Bench 4.0 where it needs xhigh to come close to 6.1 Sol, and costs more for a slightly worse result.
Not necessarily, they may have selected benchmarks where Terra performs relatively well compared to those models. Pretty much every model release these days just cherry-picks & highlights the benchmarks where their latest model performs best. We'll have to wait for the complete benchmark suite to have a better picture.
They say it has "A significant step up on factuality and coding".
My browser is underlining "factuality" in red. AI hallucinations or hallucinatiality are still a big problem in my experience.
That terminal bench 4.0 result is... bad? Terra XHigh more expensive than Sol Low and still does worse.
It's very likely this is a next checkpoint of GPT-6 "Sol", over-optimised for the web chat and offered to Codex subscribers as a "please go away" offering.
If this was half the price, I'd be very interested, but at 1/5/0.05? Feels like another panic release because they can't get Astra 6.1 out of the door...
People keep asking OpenAI for a mode that's as good as Opus 5.5, and they release this instead. Interesting strategy. Let's see how it works out for them.
They don't have anything competitive with Opus 5.5 yet. There is a supposed model in the works, "Bel" last time I paid attention to gossip, that is thought to be better, later this year. Allegedly Anthropic caught OpenAI off guard and / or their different training approaches ended up working better than anticipated.
My expectation is Fable 5.5 is next overall improvement, and my bet is OpenAI's "Bel" will be the next competitive one (or, their lack of safety culture will bite them/us in the process).
There’s also a chance they surrender the dev market altogether to Ant and just focus on the “normie” segment with dots, computer use, excel etc. In which case they won’t have anything competitive to opus-5.5 anytime soon for SWE.
This release is interesting for enterprise at API rates.
At least unless the Terminal Bench 4.0 score is more indicative than the other ones, because that one shows it clearly worse than 6.1 Sol for both performance and cost.
Taking the benchmarks (as reported by OpenAI) at face value, why wouldn't they show Opus 5.5 on the OS world benchmark, and show no Anthropic models at all on the "factual error rate" benchmark
Anthropic models are comically overpriced. They also gobble up an obscene # of tokens to get the same result as others. The price delta is literally 5x.
First we had:
> Luna (Small), Terra (Medium), Sol (Big).
Which was fairly smooth after you got used to their planets.
But then they added Astra as the "Bigger," which was mostly still self-coherent:
> Luna (Small), Terra (Medium), Sol (Big), Astra (Bigger)
But then things go confusing, they released Sol-6.1 which sometimes is superior to Astra, and discontinued Terra which made it look like this:
> Luna (Small), Sol-6.1 == Astra
But with Sol-6.1 costing the old Terra-6.0 price, while, as I said performing as good as the old "Bigger" model in many non-3D/UI situations.
Now they're re-introduced Terra, as a 6.1 release, making this even more confusing.
Did Microsoft's chief branding officer move over to OpenAI?
In general, LLM performance is incredibly multidimensional. There's no guarantee of a fixed ordering where the model that is best at math is also the model that's best at jokes. Despite that complexity, much of the variation in performance is explained by just a single variable: model size. In general, models that are bigger will (a) be more performant / reliable, (b) cost more per token, and (c) have better recall of esoteric facts. As you note, our models are ordered:
Luna < Terra < Sol < Astra
Even today, I'd recommend this as a general starting point for picking models. If you care about quality only, pick Astra. If you're a bit price sensitive, pick Sol. If you're very price sensitive, pick Terra or Luna.
Of course, model size doesn't capture all variation. Models that are trained later might have new data or new techniques or new architectures that earlier models lack. You can see this with models from all providers - Sonnet 5.5 outperforms Fable 5.1 in ways, and Gemini 3.8 Flash outperforms 3.1 Pro in ways.
In the case of GPT-6.1 Terra, I'd say Terra is probably better than Astra and Sol at technical communication, similar on vision and computer use (while being faster / cheaper), 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.
If you have suggestions on how to name our products better, I'm all ears. Our intention to make things clear and simple, even if we miss the mark sometimes.
Unfortunately, a lot of the complexity is somewhat irreducible and due to to the actual complexity of the products. Scaling model size is different from scaling reasoning effort which is different from scaling multi-agent count. So if we just swept all of those under a single name of "more IQ", it would make the naming simpler but the experience would be a lot worse, as important details would be obfuscated from end users.
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.)
> important details would be obfuscated from end users
name each model however you like, but correlate the length of the model name with the true cost-per-token (e.g. Juno is cheap, Haephaesthus is pricy)
that would quickly sort the most important detail to me, while giving me a helpful benchmark for sharing experiences with others
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.
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! :)
- 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?
> Despite that complexity, much of the variation in performance is explained by just a single variable: model size.
please release model size :p
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.
Where else would you go? I'm honestly scratching my head thinking of someplace that wouldn't run you out on a rail, but that would give serious feedback. Kernel mailing lists are out, maybe there's something like that which I can't remember off the top of my head, but...
Also, nomenclature is incredibly hard. There are only two hard problems in computer science: cache expiration and naming things.
The lineup of models is still the same.
There are four models: luna, terra, sol, and astra.
Pricing increases for each level. This new 6.1 Terra is 50% cheaper than Sol 6.1.
They are lowering prices for newer releases, so yes if you compare Sol 6.1 to 5.6 Terra it won't look right, but why are you doing that? Look at the same release version for comparable numbers.
Each model improves in successive releases but they maintain pricing and capability coherency within a release version.
Yes, Sol 6.1 is supposed to rival Astra for some work, which is what you'd expect from a later versioned release model against a prior release bigger model.
Assuming they release Astra 6.1 at some point, I expect it'll be better than Sol 6.1, at a higher price.
I don't understand what people are asking for here? No reductions in pricing? Different model names on every version release? Not releasing any models for a version number until they're all ready?
Given the operations of the model are opaque, can you see how someone (most people?) might be confused?
I see a ton of criticism and not a single person coming up with anything better, unless it's to take away options, like removing effort level.
What about buying Intel CPUs? A car? Electrical components?
If you're not just using this at a consumer level to ask about cooking recipes (and if that's your use case, you really don't care about API pricing, or any of this, and can just use the default), and are using it professionally, then this seems like a low bar of effort to understand what you're buying.
I do grant you the relationship between model and effort level has an unclear relationship, but there are also tradeoffs in most complex technical products that are not always clear; this is exacerbated by the fact that this product is stochastic.
Why are engineers using this as a professional tool expecting this to be bought like a consumer gadget and then blaming the maker?
After that you just have model "strength" and version number. But of course strength is only comparable at equal version number and the two axes are almost parallel.
Anthropic also does this, perhaps to a lesser extent.
Luna doesn't exist anymore (it's not updated)
Larger models solve harder problems, higher effort makes models work more throughly.
I think the names are more of a reference to price. Luna is always cheaper than terra which is cheaper than Sol which is cheaper than Astra (for the same model number).
Per token, yes. But per task it's not even necessarily the case depending on how much thinking is needed.
Sure Sol 6.1 on low/medium can be considered "cheap" considering its abilities, but it's clearly not meant for the same type of tasks as Luna. You just grow an intuition for when something is solvable with a Luna-sized model. I'm guessing Terra is good for the tasks that you'd typically use Sol 6.1-low for, or for Luna type tasks (or other not-novel problem) where you want to reduce the risks of suboptimal decision making. It's exactly what I'd go with for feature additions where the correct solution is already mostly designed/specced-out.
You are also rolling the training of your models by size and the lat est small model can sometimes beat an older model.
For a while we thought you just train the big model first then distill smaller models from it but since we've learnt the importance of on policy RL (basically the way a small model figures out a problem is very diff from a big model so it's best to RL optimize each model distinctly)
If you scale a model down, or switch out attention with linear attention, or introduce KV-compression, etc., you don't really know how it will affect model performance before you've trained the model.
And once you've spent millions training it, you might as well make it available if it's pareto optimal for some tasks. It also gives you more insight seeing how people use it in practice.
Yes, a more modern smaller model can beat an older bigger model at some tasks, that's what can be confusing.
But minor credit to Anthropic, at least they've mostly stuck to their four model names (Haiku, Sonnet, Opus, and Fable). You mostly know where a model is MEANT to be positioned from the name alone. OpenAI cannot keep it consistent from release to release.
But, yes, currently Opus Vs. Fable has the same issue as Sol-6.1 Vs. Astra.
Both companies have screwed up their naming royally. Maybe that's intentional - I'm sure it doesn't hurt Anthropic to have people using Fable a bit longer than they need to and racking up a huge bill in the process.
It's like iPhone 17 being faster than iPhone 16 Pro. Because it's newer and benefits from advances in chip architecture, despite being a lower model tier. Sometimes different iPhone models are released at different times.
It's nice that they have Terra which seems to fill a void that's been needed since Sol 6 focused on cost (at the expense of quality), Sol 6.1 got a huge boost in quality, but became unusably slow unless you paid Astra prices - at which point, why not just use Astra?
Now at least we have a viable other option again.
And some variants (e.g., the medium one) being skipped or delayed for a certain generation doesn't really change the overall size branding.
“Test them all”
Virtually every task I give to either is better served by going up a tier and down a reasoning level, or down a tier and up a reasoning level. I simply don't understand their use case. No testing I've done has shown them to have a niche where there isn't a cheaper-with-equal-results or more-performant-at-same-cost option.
If you pay API prices for inference in your product stack & have specific use-cases w/ custom evals, these smaller models provide an additional cost/speed lever to adjust. Ultimately, I think the point is to compete on cost for use-cases where Sol on the lowest reasoning is overkill.
If you have a fairly straightforward usecase where Terra performs just as well as Sol, but is faster and cheaper, why not use it?
On subscription for coding and stuff I am basically on Astra Ultra all day long.
I think it's also a fake lever to give to finops / it teams to try and keep costs down.
To justify the pricing of Sol and Astra. Old business trick.
if you're just talking about use in codex or claude code, then sure, leave it on opus all the time. but for running routine api requests, sonnet is great.
But like the original release of Terra, it's still a weird middle child between the small-model-that-got-substantially-better (Luna) and the large-model-that-got-significiantly-cheaper (Sol). The TerminalBench 4.0 cost-per-task results are a bit confusing and I'm not sure why you would pick Terra over Sol in that case. Overall this release seems like a flex on Sonnet 5.5: a model which is having its own middle child problems between the godly Opus 5.5 and the surprisingly capable Haiku 5.5.
Interesting that both "none" and "low" reasoning levels appeared not to spend any reasoning tokens at all, and in fact low ended up using less tokens and costing less than none here.
"medium" did use 496 reasoning tokens, but that's apparently not enough here to return a visible reasoning trace.
OpenAI's current frontier model lineup is gpt-6-astra, gpt-6.1-sol, gpt-6.1-terra, gpt-6-luna, so here's a comparison grid of all of their pelicans at different reasoning levels: https://static.simonwillison.net/static/2026/openai-pelicans...
I'm optimistic about them tackling frontier intelligence next. Astra 6.1 please?
The pelicans place it nicely between Sol and Luna in terms of both pricing and results.
Previous Terra model was so good it was discontinued.
OpenAi needs a model to compete with Opus 5.5, and that's not Terra 6.1.
If not, yawn...
It's very likely this is a next checkpoint of GPT-6 "Sol", over-optimised for the web chat and offered to Codex subscribers as a "please go away" offering.
If this was half the price, I'd be very interested, but at 1/5/0.05? Feels like another panic release because they can't get Astra 6.1 out of the door...
My expectation is Fable 5.5 is next overall improvement, and my bet is OpenAI's "Bel" will be the next competitive one (or, their lack of safety culture will bite them/us in the process).
At least unless the Terminal Bench 4.0 score is more indicative than the other ones, because that one shows it clearly worse than 6.1 Sol for both performance and cost.
let's see if it can pass the Pangram test. Many services purport to fool it, but fail.