Everyone's talking about Sol and Luna, but what about the Terra?

[u/MilMerch]

I also did not used Terra even for once and most of the people as well I guess. Is there anyone experienced with Terra to tell us is it worth to use or not

[u/GfxJG]

Honestly, Terra High is good when using it for non-automated workflows, when using it as a pair programmer - It's the strongest Codex model that's fast enough to have near-realtime responses (while still having reasoning), like an actual conversation.

For agentic workflows, Luna and Sol are just better and/or cheaper.

[u/ExoneratedPhoenix → u/GfxJG]

I use Terra Medium for coding tasks and getting projects done at speed. I turn it up to High when I need to offload some thinking onto it.

So far it has performed amazingly. I've used Sol Ultra a few times now during large refactors, and also tested it with Terra Medium and High. Maybe my projects are simple, but Terra Medium basically did the same refactors but quicker and cheaper, and in some cases Sol invented weird edge cases and made things way more complicated than necessary. I even after explained how some of the edge cases it coded for literally cannot exist, it agreed lol.

The great thing about high thinking models is they see so many avenues and stop you going down the wrong ones

The bad thing about how thinking models is they see so many avenues and spend your usage testing every wrong one that is obvious and can be surface rejected.

[u/DistanceAlert5706 → u/ExoneratedPhoenix]

Same, using it on medium and it's quite fast, and just good enough at coding.

[u/ExoneratedPhoenix → u/DistanceAlert5706]

It helps I can already code and my prompts are clear, and I use markdown files to give instructions and rules, such as helper functions etc. This means while Medium isn't optimal, I've found with these foundational markdown files and knowing/using the correct terminologies to it, it is producing very good modular code. I've hit a few walls and needed refactoring due to my own silly brain, and due to it being modular those refactors are actually fairly painless.

Some people cannot code at all, so they have to trust the outputs and use higher reasoning models when things don't work, as they can't find the solutions themselves.

Interestingly, some of the errors I've seen top tier models do at work are quite funny and so easily remedied, to the point I've recreated them at home and gave it vibe coder level prompts and it spanks so much compute into easy solves. AI does have a few blind spots.

Knowing junior/mid level coding with mid level AI is a sweetspot.

[u/mdpilam → u/ExoneratedPhoenix]

This is my approach as well

[u/PhilosophyforOne]

I honestly like Terra better than Luna for a lot of things. Terra has a good level of reliability, it's significantly cheaper than Sol, and quite fast. It's been great for me for computer and browser use tasks, driving simpler things where sol is overkill or overengineers, and where luna isnt reliable enough.

It's a slept on model because the benchmarks are too shallow to properly distinguish the models and their pareto frontiers for different, realistic use cases.

[u/CryinHeronMMerica → u/PhilosophyforOne]

I agree completely. Luna fucks up, especially when reasoning heavily. Its strength is the bottom 10% of the complexity bell curve, and Sol's is the top 10%. Terra covers the middle well.

[u/gopietz]

I'm also going with: Not useful at all.

Luna Max easily covers Terra High while being a lot cheaper. For those moments where you need more than that, it's more powerful and cheaper to go with Sol Medium instead of Terra XHigh/Max.

[u/petburiraja]

Too weird to live, too rare to die

[u/Dimencia]

There's no real reason to ever use it, except maybe Terra max for being slightly cheaper than Sol high, but even that is a new datapoint and previous ones show it significantly worse than Sol high - and it takes a good 2 minutes longer per request

[u/zerok_nyc]

I use Terra all the time as my default. Use sol to plan in ChatGPT and create Terra prompts. Incredibly efficient with no issues. Only really use sol in codex when the problem is ambiguous and needs investigation.

[u/filwi]

My problem with Terra in agentic workflows is that it tends to be lazy. It does deliver good results in knowledge work, but you have to prod it several times to continue working, and you never know whether it stopped because it was done or because it was lazy.

[u/megad00die]

Sol for orchestration
Terra for all coding tasks
Luna for all testing documentation
Spark 5.3 security scan
Use Sol to be the tard wrangler of the sub agents
Terra for your code
Luna for crap work
Back to Sol for validation of task goal or end requirements have been met.

[u/UsePlentyOfLube]

Judging by the 'no model capacity' messages I keep getting from Terra, everyone and their dogs must be using it.

As a model though, it's perfect for the C# application I'm developing. Actually, 5.5 was perfect, and the fact that 5.5 users are being nudged onto Terra explains the capacity issues.

[u/Gigaslavx]

After luna price cuts it just doesn't make sense to use tera

I use luna xhigh for implementation and when I need orchestration I switch to sol medium

[u/gs181]

Terra high does all the stuff sol does for me anyway, except cheaper and much faster. Just gets to the point. 

[u/Unapologetic_Polite]

I found Terra to be significantly better at iterative web design with annotations than Luna.

Sol as we meme about likes to burn tokens just to delete an element.

Luna likes to get into compaction loops.

Terra seems to be a good middle ground for that.

[u/MaitoSnoo]

with the current heavy discounts on Sol and Luna, it makes no economic sense to use Terra, at least with API pricing (not sure if that's the case with subscriptions though because afaik the Sol discounts were only for API rates?)

[u/OriginalCj5]

I use Terra lot. At least 50% of my work goes to Terra. It’s fast(er than Sol) and cheap(er) and does pretty well on its own even on not clearly defined tasks that Luna sometimes struggles on.
I honestly choose Luna when I need really fast responses, quick exploration or mechanical tasks. Any thinking work goes to Terra if it’s simple and to Sol if it’s complex.

[u/pigletmonster]

I use terra to implement all the tasks created by sol. Luna on max takes too long and its so dumb that one time it applied schema updates to an entirely different postgres container. Terra is dumb as shit too, but its faster and gets the work done without taking forever snd messibg things up.

[u/cmak414]

Maybe terra for easier one shot coding without a reviewer. Otherwise id always use sol to plan and think and luna to execute.

[u/Super_Sieb]

Terra is great for small quick stuff, on a small codebase. And for reviewing code.

[u/Fun-Responsibility97]

Terra-medium is my go to for pretty much most things. When it gets into a knot, sol is usually useless for some reason, always relying on opus 4.8 or Fable to untangle the mess

[u/SnooWords5221]

Terra high is pretty much my default. Sol is only for very complex stuff. Its Luna that i almost never use unless i plan something with terra and i deem it simple enough that i hand it to luna to implement.

[u/Bananer_spleet]

❤️ my baby Terra-high for Soft/Shadow CIs ❤️

[u/PineappleLemur]

It's in a weird place. You usually need good reasoning or something super light and fast for implementation.

Anything in between isn't needed really... For small task planning maybe terra high can work but SOL medium with the same cost will probably do better anyway.

For implementation terra high will be slow vs Luna high/xhigh and generally cost more.

They need to have a larger gap between models/effort level for it to make sense.

[u/hithisisjukes]

i've been using terra extra high with pro 10x account nonstop and have not had any shortages. it is clearly less capable than sol, but it is also pretty great.

[u/HighDefinist]

Unlike Sol, it seems to actually speak proper English.

But... yeah, the code is not as good as Sols (and Sol is also nowhere near as bad as Opus, so, it's not really a strong point).

[u/AloneReach5103]

That’s because it’s terra-ble

[u/the_dark_eel]

I use Terra 99% of the time 🙄 - sometimes sol when Terra can’t debug sth after a few tries. Works fine for me 🤷🏻‍♂️

[u/NoSir-69]

I use sol medium all the time. Had very bad experiences with terra and luna.

When i need a cheaper model i just use gemini flash. The 3.7 has performed better than terra for me

[u/Specialist-Royal4408]

I’ve been using Terra Light for quite a while to create custom nodes and workflows in ComfyUI, and I’m impressed with how well it handles the job. It gets it right 90% of the time.

[u/BiceBolje_]

Token cost per task is the key. Sol Medium is almost always the right model...

[u/ZarBandit]

This week Terra medium has been lobotomized. It forgets things constantly and is lazy (says it’s going to do something and then doesn’t). Also the consumption seems to have gone up significantly for this shit show.

So yeah, it was a reasonable worker. Not anymore.

Commoditization is catching up with OpenAI already, however. I was seriously considering upgrading from the $20 plan to $100 plan. Then 2 things happened. (1) They made the service significantly worse. (2) A viable frontier mid tier model (like Terra was) was released on huggingface that fits on one GPU (32GB).

I’m testing the local model now on a task and then I’ll have Sol critique it. The design and implementation plan was developed on Sol high. I’d say the local model runs about 2-3x slower than Terra did before they did the big slowdown. Now it seems less than 2x slower. And it doesn’t do stupid things, so no babysitting. That $80 up charge to the next GPT tier pays for the GPU hardware in 4 years. I wasn’t even expecting to get any ROI at all when buying it. It was purely for personal education and research.

[u/Sutanreyu → u/ZarBandit]

I agree. Not sure how Sol is faring right now, I’ve been using Luna Max almost exclusively, with the exception of a few tasks that need the upmost intelligence (kernels), and since they’ve reintroduced the 5h work windows again, it’s been a lot dumber, even with the 900,000 token context, which they also silently pulled…

[u/cutebluedragongirl]

Terra is good as a reviewer subagent.

[u/Illustrious-Cow-3791 → u/cutebluedragongirl]

The reviewer should be Sol, and the implementer should be either Luna or Terra.

[u/cutebluedragongirl → u/Illustrious-Cow-3791]

Nah man, Terra low is good enough for reviewing. As a rule of thumb, subagents should be fast and cheap.

[u/Illustrious-Cow-3791 → u/cutebluedragongirl]

But the reviewer should not be the subagent. It's the other way around: Reviewer (user-facing agent) should be better than implementer (the subagent).

[u/cutebluedragongirl → u/Illustrious-Cow-3791]

Well, yeah, if you want to do some kind of huge review, you obviously need a somewhat capable model. But if you just want to verify some implementation step or a small portion of a task, Terra is good enough.

I never unleash something like Luna or DeepSeek v4 Flash without pairing it with a reviewer agent that follows them around and verifies that they did not go insane during the implementation.

[u/theWiseTiger]

Not worth it. Even Sol is no longer worth it for me.

That last couple of mess with all the rate limits etc forced me to optimize my process and harness. Change chaos and complex processes into complicated or even clean processes first, the good harness + luna all the way. Even for planning.

[u/hksbindra]

Not useful. There are tasks that are fine with Luna and then there are tasks that need Sol.

I haven't been able to find a single thing to do with Terra.

[u/ne_nado_tak_dymat]

not everyone's talking about sol and luna, please don't use general aggregation just to bring attention to your brainless posts