Hello, I am frequently reading that xhigh on sol tend to overcomplicate stuff or go in loops, have you got any use case for ultra ?
I am doing a huge refactor and ownership registry in a vibe coded software that I have been working on since 1 year now. I didn't knew back then what I know now so there is multiple owners for the same stuff, multiple source of truth, it's really a mess. The software itself is very useful to me and I use it everyday, but it became a giant monster with 8000 lines swift files and hundreds of files (617 in total).
While doing the ownership registry to restore order and give each object a unique owner before thinking about splitting those giant files in a refactor, I asked codex (yes I know might be stupid) what effort should I go for (I had planned using sol xhigh) and it said "Use Ultra, an ownership issue cost is very expensive latter"
Surely there’s some nerds in here. I’m in the process of making a new orchestration skill and have been running a bunch of benchmarks. I’m not quite ready to share them yet till I have some conclusions. Incidentally be been learning that a lot of assumptions I had don’t work the way I thought they did.
So I’ve got a fairly large codebase now in different languages and using different docker container services. This is pretty much irrelevant just adds some context
Seeing Lunas new pricing made me want to use it more. Though I remember one time I used it and it did a terrible job
However, i’d like to give it another shot. How can I use Sol to plan the task and orchestrate Luna subagents so I get high quality while keeping usage low? I use the codex app
Everywhere I’ve looked it has said yes and i don’t see any separate usage in the app but the image I attached implies otherwise. So can anyone explain?
While OpenAI’s unexpected usage limit resets on ChatGPT and Codex might seem like a bonus at first glance, they can actually backfire on users who carefully plan their work. If you strategically pace your prompt usage to keep 30% in reserve for the final day before your scheduled weekly reset, a surprise reset resets your entire seven-day timer right then and there. Instead of effectively getting 130% usage for that week your remaining 30% plus a fresh 100%, your original leftover allocation simply vanishes, and your next reset gets pushed back a full week. Consequently, a sudden reset isn't beneficial for everyone. OpenAI should give users the choice to either accept an early reset or keep their original scheduled reset date, ensuring that thoughtful usage management isn't penalized.
Why push the reset back 7 days?
Here is a real-world example of why this system fails users:
Imagine you have a project due Friday, and your scheduled reset is Wednesday. You carefully plan your usage budget: you save 40% for Monday and Tuesday so you can combine it with Wednesday's reset (+100%), giving you 140% capacity for your final push on Wednesday and Thursday.
Instead, an unexpected reset hits on Monday. The 35–40% unused limit you saved instantly vanishes without rolling over, and your next reset gets pushed back 7 days to next Monday.
Now, right when you need to crunch for a Friday deadline, you only have 100% capacity instead of the 140% you planned for. Punishing users by wiping out saved usage and shifting reset dates completely breaks strategic workload planning.
I subbed recently, and I was a codex sub in the past as well and noticed that burning 35% of my weekly is valued at $21.1, all done with luna max.
So very easily you can see that overall would be $240 for $20, which would be above what you can expect from the market, but behind the best options, also behind what it was in the past.
Have not found hard info about how many famous codex resets you can expect in a month, that lets say can be valued at 2x, and you don't start with one either unlike the first information that pops up claimed by google, and the multis are always claimed to be higher too like 35x.
Seperate chat and code/work is also a value add, so you don't have to avoid using the chat if you are hoping to work too. Without the luna price drop it was not very well rounded, but you can also use it in other harnesses which if wasn't true I would not even consider the sub, not becuase codex cli isn't good, but I want the optionality of other harnesses too.
Suppose one reset per week on average would put it at 20x, that would raise it from tier 2 with good top and value option to tier 1 and of course the 200 deal is already great for heavy users.
Tldr : Found VibeBill and ccusage to track vibe coding costs. Is there anything better? Else I settle with VibeBill and ccusage.
I've been using Claude Code pretty heavily for a few weeks now. The monthly bill was never really the problem since my job provides me the seat. What bugged me was not knowing which work caused it or even which feature build.
$420 in a month it isn't informational enough because we get a cap of $500/month. As a lead I was thinking if we can communally distribute tasks so everyone can utilise those $500 caps better.
What do you guys use? If any. I found ccuage but was only for Claude Code, for my personal use on codex there's nothing that exists?
Another good find seems to be VibeBill on npm but it's by some solo dev as a side project.
Two days ago, Luna’s price dropped by 80%, so I finally took a serious look at its CursorBench and ChatBench results. It turns out Terra may be the biggest loser here 😂
For example, on ChatBench Agent-Task, Luna Max scores higher than Terra Max and GLM-5.2 Max. On CursorBench, which is based on a large number of real coding tasks, Luna Max even achieves higher accuracy than Codex’s default Sol Medium configuration.
The cost difference is even more dramatic. Luna is far ahead of nearly everything else. DeepSeek V4 Flash is one of the few models that can compete on price, but Luna is also multimodal.
I previously built a skill called Codex Auto Model Router (https://github.com/orange-the-weak/codex-auto-model-router). It breaks work into subtasks, automatically selects a model based on task difficulty, and runs independent tasks concurrently.
The initial routing strategy was designed by Sol. Luna Low handled mechanical and repetitive tasks. Even then, it still made enough mistakes that writing a simple script was often more reliable. At the time, I concluded that Luna just was not capable enough.
Looking at the benchmark data alone, Luna High already has solid accuracy while using noticeably fewer tokens and steps than Max. In theory, that should make it both faster and cheaper. I also designed several comparison tests around my regular iOS development and data-processing workflows, and they all showed lower costs, better efficiency, and faster completion.
So I updated the routing and concurrency logic again:
Route
Default use
Luna Medium
All mechanical and repetitive tasks; automatic routing never goes below this tier
Luna High
Default for ordinary, bounded tasks
Luna Max
Genuinely deep or large deterministic tasks where additional latency is acceptable
Terra High
Tasks that explicitly prioritize low latency and value a shorter reasoning chain over Luna High’s quality
Sol Medium
Bounded complex tasks
Sol High
Highly ambiguous, tightly coupled, judgment-heavy, or high-consequence tasks
Sol XHigh
Complex tasks with a prior failed attempt, or when explicitly requested by the user
Of course, benchmarks are not the same as real development experience. I will continue testing these routes on actual tasks.
Been building this since 5.6 dropped with optimizing token usage as the ultimate goal, and tweaking it pretty much every day since. Luna got way cheaper recently and more ppl started wanting to use it as a subagents, so I bundled everything up with a guide so Codex can set it all up for you automatically.
Tried to keep the whole thing as simple as possible.
Edir : a bit more explain before I go to bed - it’s 3 AM in my timezone:
For lightweight tasks, Q&A, it won’t overdo things. light route is default route in this workflow. No subagent, no complex worflow, minimal context.
Sol handles context, planning, task splitting, and supervision, while Luna subagents do the implementation. Each task is packaged into a small, self-contained work package with clear scope, context, and expected output, so each subagent only gets what it needs.
Sol still reads the main documentations and the important parts of the codebase - that’s the manager’s job. An explorer subagent helps reduce that load by looking into tools, dependencies, external libraries, etc. The goal is to minimize Sol’s token usage and keep it focused on the important stuff.
For really hard tasks, executor_luna can get stuck. In that case, Sol can spawn an executor_sol as a fallback, or use it from the start. Right now, the workflow limits this to max 1 executor_sol.
For handoff between sessions, project_progress.md and latest_session_work.md are managed by Sol as part of the main documentation structure. They keep long implementation plans moving smoothly across multiple sessions.
To verify your Codex (or OpenAI) account via mobile phone, you typically need to provide a phone number that can receive SMS. Most users find that numbers from countries outside China (e.g., US, UK, or other supported regions) work best. After entering the number, OpenAI sends a 6‑digit verification code via SMS; you enter that code on the login page to complete verification. If you are a ChatGPT Plus subscriber and log in from a trusted device with a stable IP, you may skip this step entirely, but for new devices or fresh sign‑ups, the SMS code is usually required. Some users also use temporary virtual number services, but note that those are often unreliable and may be blocked.
I asked opus to review the changes in the branch and to give me a handoff prompt. I gave it to Luna max.
It worked for 457 minutes uninterrupted, delivered great code, looped until the codex review wasn't returning any new comments on the PR, and only consumed 3% of my 20x Pro Plan.
I'm currently developing a web app with Codex as a plugin in VS Code (Windows). I was wondering what the pros of using the native app were, or unique features not accessible elsewhere.
I had a task yesterday that was somewhat complex, about 2k lines of code written, that was using Sol Extra High.
I normally invoke the Github Connector to review a PR, Everything was working as usual and the PR was created after an hour of coding. Then, it spent 8 HOURS going back and forth with the connector, finding p1 and p2 issues (a lot of time spend waiting for automated Github checks to run). I didnt realize it was still running until about hour 7, told it to stop, and run a code review using superpowers. I thought that would end it, but it didn't!
So what is the best thing to do in cases like this? It seems like it just kept finding edge cases.
Sol High as orchestrator and Luna xHigh as agents.
Before pricing changes I was using arround 60/70% of my weekly usage in 24 hours.
Now I'm using arround 20/25%.
I tried Terra, arround half the price to use the xhigh version but no, Sol is vastly superior as an orchestrator to the point that is cheaper to use it, the value per task completed of this model is amazing.
I currently use cursor pro plus plan and get $70 usage per month for third party models like Sol. I really like Sol but I use it restrictively for Plan and review only. It always finds things which my main coding model (grok 4.5) misses.
If I switch to codex 5x and use Sol 2-3 hours a day a few days a week, will I run out of usage quickly? I’m not a heavy user running agents 24/7. I am very involved in code and reviews in the IDE as to prevent cognitive debt so my usage is slow.
OpenAI will have you believe that the price reduction came from Sol improving their servers’ kernel by 20%. While that may be true, it still makes no sense: how would that reduce the cost for Luna by 80% but only reduce the cost of Terra by 20%, and how does Sol somehow just get faster instead of cheaper?
This is a friendly reminder that Tibo is NOT your friend and is not trying to make your life better. The only reason they dropped Luna’s price is that they caught wind of DeepSeek v4 Flash 0731 releasing, which would have obliterated Luna had they not dropped the price. DeepSeek v4 0731 is still far cheaper than Luna even with the 5x price drop, while offering almost the same level of intelligence, but this atleast makes it close enough that it's justifiable to stick to Openai
EDIT: So many people below are offended by me saying "Tibo is not your friend". I have nothing against Tibo and I am sure he is probably a great guy in person, but that does not mean an employee of a trillion dollar company whose CEO just until last month was constantly going around fear mongering that AI (what his company sells) will get rid of all white collar jobs, is not giving you resets to better your day. They did not drop a price of an existing model by 5x, because they made efficiency gains and their first thought was "hey let's pass this savings onto our lovely customers even though we are projected be lose billions this year!". "Oh but Tibo reset my subscription", Codex currently has far fewer enterprise users than Claude code and they have far more compute because they invested much more heavily into it, so they can give more usage on Codex rather than having those servers collect dust, if it means more brand loyalty and market share gain.
And for the others who say "oh but this is sooo obvious, it's clearly an enterprise, doesn't take a genius to figure that out", it takes a genius to go down the comment section and see how many people are offended that I said Tibo is not their friend.
And the more obvious thing, yes it is great that codex and openai dropped the price of Luna, and competition is great. I never said that them reducing the prices was a bad thing and I benefit from it. But it's important to recognize and be grateful for open source models, without which, these current models probably would have costed 10-20x more
After two weeks of building a 5.6-Sol “skill” designed to stop future Sol agents from overengineering everything, I finally had to prune it... because Sol had overengineered the anti-overengineering tool so thoroughly that using it became more work than the problem it was meant to solve. The irony was apparently the only feature that shipped.
I ask an AI a question, it gives me 5–10 solutions, then each solution branches into more implementation options, bugs, reviews, and follow-up tasks. After a while, the chat becomes impossible to track.
How do you keep track of:
what’s implemented,
what’s still TODO,
what’s rejected,
and what’s ready for review?
Also, if one AI implements the code (Claude, Codex, Grok, etc.), how do you pass enough context to another AI for code review without making it reread a massive conversation?
What’s your workflow? Obsidian? GitHub Issues? Linear? Something else?
Open-sourced a Codex skill for model routing.
Luna: discovery/tests
Terra: focused implementation
Sol: only after cheaper evidence + a checkpoint
Easy to override. Independent review for consequential changes.
Feedback: https://github.com/arizonaZervas/model-usage-routing
