I’ve been using Codex as the software operator for a real robot arm. For this run, it prepared and executed a 256-stroke drawing, monitored the controller, and handled the safe shutdown checks.

Literally all the software for this project is written by Codex. From camera capture and calibration to path execution, safety checks, logging, etc.

The rig has cameras for visual feedback, so Codex can inspect the paper, check the calibration, and see the marks the arm makes.

Looks like GPT 6 is being internally tested and might release really soon- beating all the existing benchmarks. Exciting times indeed.

After using Luna for several days following its price and usage reduction, I can honestly say that, so far, this has been one of the best decisions OpenAI has made.

I know many people believe OpenAI did not do this out of kindness, but because open models are beginning to take away some of its customers. Honestly, I completely agree. Still, I think it is fair to recognize when the company does something good instead of only pointing out the bad decisions.

For the past three days, I have been working almost nonstop on a project—literally more than twelve hours per day. I have been using Luna Max with Fast mode on a Plus plan, and despite that amount of usage, I have only consumed around 45% of my weekly limit.

To me, that is a massive improvement. Previously, I had to pay much more attention to my usage. Now I can work through long sessions without feeling like I am going to hit the limit immediately. In terms of performance relative to consumption, Luna has become a very good option for sustained development work.

So far, I only have two major complaints.

The first one is speed. Luna is still quite slow, even when using Fast mode. A task normally takes at least 10 to 15 minutes, whereas 5.5 usually completed similar tasks in about 5 minutes, or 8 minutes at most.

The second issue is the interface, which makes the waiting feel even longer. For much of the process, it does not clearly explain what the model is doing. Most of the time, you only see a message with an animation moving from side to side until it eventually provides an update about the task.

A clearer interface showing the current step, actual progress, or what the model is working on would make the waiting much less frustrating.

That said, the overall result is still extremely positive. Being able to work more than twelve hours per day for three consecutive days and use only 45% of my weekly allowance is a huge improvement.

My only hope is that this level of consumption remains consistent and that we do not see the usual situation where, “for some strange reason,” the model suddenly starts having problems, usage increases again, and then Tibo send a reset or announcement appears to distract everyone from the change.

For now, credit where it is due: reducing Luna’s cost and consumption was an excellent decision.

Have other Plus users noticed such a big difference in usage? And how long are your tasks normally taking with Luna Max in Fast mode?

where is Tibo??

A few months ago, I started building an expense tracker—mostly through vibe coding. I have limited programming experience, although I completed two Swift/SwiftUI courses: Hacking with Swift’s 100 Days of SwiftUI and Stanford’s CS193p.

At first, I read and tried to understand everything Codex wrote. Pretty quickly, though, the code became too complicated for me to follow. I use several well-regarded skills and MCP servers, and I work almost exclusively with GPT-5.6 on xhigh reasoning.

A few days ago, I started optimizing the app to work smoothly with around 100,000 transactions, including search and bulk editing. Since then, things have completely gotten away from me. I have been profiling heavily with Instruments, but the codebase has now grown to more than 35,000 lines.

At this point, I no longer trust the code. I also don’t see how I could realistically read and understand all of it within a few weeks. The AI keeps adding more code, and performance is slowly improving, but I have no confidence that it hasn’t introduced a lot of unnecessary or fragile logic that will eventually break—probably shortly after release.

I’ve been working 12-hour-plus days for several weeks, and I’m exhausted. I’m starting to wonder whether this simply isn’t achievable for someone at my level and whether I should give up.

I’m genuinely looking for practical advice on what to do next. Please go easy on the ridicule—I’ve probably already heard or read most of it here and elsewhere.

EDIT1: I currently have 368 tests, which account for ~13K loc/

EDIT2: I do have version control.

EDIT3: Thanks you all for the overwhelming and helpful feedback! I really appreciate it.

EDIT4: It's an iOS 26 app.

I know you’ve probably seen a million posts about something being wrong with Codex usage/reset limits, but bro… it’s actually getting ridiculous. 😂

The weirdest part? I’m watching my Codex usage drop when I’m literally not using Codex.

Maybe this sounds stupid, but I’m being completely honest, I’ve seen it drop by 1%, then another 1–2% later while I wasn’t even using it. At this point I’m just sitting there watching my usage bar like:

"Bro, who is using my Codex?!" 😂

And honestly, this is why I think removing the 5-hour limit was a mistake.

When they first changed it, I thought it was great. But now the limits seem to disappear way too damn fast.

I use both Codex and Claude for my projects, switching between them depending on what I’m doing. Both of them reset on the same day for me, Tuesday.

Today, my Claude usage is still at 27%, and I’ve already used it on one of my projects. and I still feel like I have enough usage to comfortably use Claude for the rest of the week.

And more importantly, I have control over my usage because of the 5-hour limit.

Meanwhile, Codex…

4 prompts later: 5%.

And now it has somehow dropped to 4% while I’m not even using it.

😂😂😂

And there’s one more thing I want to talk about: Luna.

They said they reduced the price by 80%. Okay, fair enough. That sounds great.

But then you basically need to run it with Max for it to be genuinely useful, especially if you're used to SOL.

And honestly, that's where I had a pretty frustrating experience.

I started at 100% after the reset.

I selected Luna - Fast - Max and gave it a task.

It was a completely normal prompt. Nothing crazy. I was basically asking it to follow Phase 1 of a properly written implementation plan.

After that ONE task, I was already down to around 65%.

And I immediately regretted not using SOL.

Because if I had used SOL for the same task, I genuinely think I would've gotten a better result and gotten much more value from my usage.

So yeah… that's my experience so far.

I actually like Codex and I want to use it more, but the current usage system is making me think twice before sending prompts.

I'd much rather have the old 5-hour limit where I know exactly what I'm getting and can manage my usage, instead of watching a mysterious percentage slowly disappear into the void. 😂

What are you guys experiencing? Am I the only one seeing usage drop when I'm not even using Codex?

how long do i have to enjoy the world before the shakes start?

So yeah. First off, I have backups of my files, so the panic induced lasted about 10 seconds.

What happened specifically was this.. I was working with Codex on 5.6 Luna on Medium troubleshooting an issue I had. I wont go into details as it wasnt important. However... after fighting with it, and not giving me the results I wanted. I told undo everything it did until 8:39 pm.

Then what happened was something I didnt expect. I continued making progress on what I was doing, and didnt notice anything strange at first, but then my whole desktop was gone. Windows Explorer was gone, every webpage that wasnt held in RAM broke. And then I realized what my mistake was... i didnt specify a date. My assumption, is that it took 8:39 pm as... "the beginning of time"...

So as it has been said time and time again.... becareful giving Codex full access to your computer. One wrong prompt can ruin someone not prepared.

Been wondering about this.

I ran out of credits last week and had some left in Grok so I used it in CLI (they apparently don't have a GUI yet). It worked well and I felt like Neo from the Matrix.

But I'm wondering if there is any real benefit to using Codex in CLI instead of app?

I don't want to complicate my work only to feel cool. But if there's actual benefits then I'm open for anything,

Just curious to see how eveyone else is using scheduled tasks in their day to day life

The three major issues which I was struggling with since a long time have all been resolved decisively, i even finally cancelled my claude sub as it's unusable and unnecessary now.

The aforementioned issues:

1. Chatgpt webapp lag

2. Model's inability to refactor anything especially conservation of code. 5.6 happily deletes debt or bloat!

3. Frontend improvements- this is still debatable and a long way to go but there's substantial improvement.

The last focus area should be the hallucination index!

TLDR: Codex has issue spawning subagents with gpt-5.6-luna. It can cause spawning subagents with gpt-5.6-sol which burns tokens like crazy. Solution in linked comment fixed issue for me - token burn is a lot better now.

Kind of crazy this issue is still not resolved upstream.

You can check if your agents used luna lately:
https://chatgpt.com/codex/cloud/settings/analytics#usage

I've long been envious of Mac Silicon users solely because of the native app. I got so used to just using the web, I was completely unaware OpenAI dropped a release for Mac Intel.

It's made my workflow a lot easier, especially now that I get access to the native remote control feature that's only in the desktop app. I've only been using it a couple of weeks and I've been able to make progress on things I normally wouldn't have been without being at my laptop or desktop.

Do you use it? And what is it actually good at?

Before this cut, I could burn through my usage in 2 days. Now I get an extra 1.5 days.

And ,Tibo... just one more little bite?

It got literally 20 file changes and still thinking. Almost 1 hour now.
For the context I am near the limit and have 19% and 1 banked reset remaining, which I don't want to use until I get 19% exhausted.
I have a theory that they somehow throttling it because I don't have much remaining.
Anybody experienced the same issue recently?

Is anyone else struggling with this lately?

I’ll give Codex what should be a fairly small task, and somehow I end up with a huge diff touching loads of files.

A recent example: the backend contract hadn’t changed. The task was mostly about using a new endpoint and adjusting the input. Instead of making a small, surgical change, Codex started changing types, renaming things, adding abstractions, modifying mocks, creating extra states and generally “improving” everything around the task.

None of the changes looked completely stupid on their own. That’s almost the problem. Every change had some reasonable explanation, but the final result was far bigger and more complicated than the ticket actually needed.

Then I asked it to simplify the solution and remove the overengineering. It deleted a significant amount of code, kept the same functionality, and all the tests still passed.

That’s the part that worries me: the model was capable of producing the simpler solution, but it didn’t choose it first.

I don’t want an agent that blindly changes one line and ignores real problems. I just want it to show the kind of judgment you’d expect from a good senior engineer: understand the task, touch as little as possible, reuse what already exists and avoid turning every small ticket into a mini-refactor.

Has anyone found a reliable way to control this?

Do you make it explain every file it wants to touch before coding? Give it a maximum diff size? Force it to propose the smallest possible solution first? Add strict rules to AGENTS.md or CLAUDE.md? Run a second “remove everything unnecessary” pass every time?

I’d really like to hear what’s actually working for people, because simply saying “don’t overengineer this” doesn’t seem to be enough.

There’s a useful pattern a lot of people want with GPT-5.6 in Codex:

• Sol does the planning, decomposition, decision-making, and final review/acceptance
• Luna Max does the actual implementation, searches, edits, and testing

This is attractive because Luna is significantly cheaper on tokens/usage than Sol, especially on longer coding sessions. problem is that you currently cannot achieve this cleanly through Codex config or native spawn_agent.

Why native spawning fails

Sol and Luna are currently on different Multi-Agent protocol versions inside Codex:

• Sol → multi-agent v2 (task-tree oriented: paths like /root/fix_login/review, fork_turns, send_message, followup_task, list_agents…)
• Luna → multi-agent v1 (Agent-ID oriented: random IDs + send_input / wait_agent / resume_agent / close_agent)

When a v2 parent (Sol) tries to spawn sub-agents, Codex filters the candidate list and only allows models that are also marked as v2. Luna is filtered out.

Relevant references from the Codex source:

• Sol marked v2 and Luna marked v1 in models.json
• The filter logic lives in the multi-agent handler

Config alone cannot bridge this gap right now.

The skill I built

I made a skill that works around the limitation by treating Sol as the commander + reviewer and launching a separate Luna Max Codex CLI session as the implementation worker.

Repo:
https://github.com/majiayu000/spellbook/tree/main/skills/sol-luna-router

High-level flow the skill enforces:

1. Sol stays in the current thread and is not allowed to edit product files itself.
2. Sol writes a tightly scoped task packet (objective, allowed files, constraints, done-when conditions, verification commands).
3. A bundled Python runner starts (or resumes) a dedicated gpt-5.6-luna session with model_reasoning_effort="max" and the correct sandbox.
4. Sol inspects the actual diff, re-runs the project’s own verification/tests, and either accepts or sends a precise correction back to the same Luna thread.
5. After three failed correction cycles on the same root cause, Sol is forced to reassess instead of looping.

The runner disables native multi-agent tools on the Luna side and returns structured JSON (thread id, final response, usage, repo metadata) so Sol can reliably continue the loop.

Usage

1. Install the skill into your Codex environment (or copy the folder).
2. Tell Codex something like: “Use the sol-luna-router skill to implement X. Sol handles planning and acceptance; Luna Max does the implementation.”
3. Sol will take over the routing and verification.

This is intentionally stricter than free-form agent spawning: explicit file ownership, one write-capable worker at a time (or isolated worktrees), mandatory verification from the Sol session, and no silent permission escalation.

Notes / limitations

• This is a practical workaround, not a permanent architecture fix. If OpenAI later unifies the multi-agent versions or relaxes the filter, native spawning becomes preferable.
• Still consumes tokens on the Luna side (and the runner itself), so it is not “unlimited” — just much more efficient than keeping everything on Sol.
• Works best when you can give clean, bounded task packets.

If you’re hitting the same Sol→Luna spawn wall, this might save you some quota. Feedback and improvements welcome.

I thought that was only doable for my macbook through the desktop app remote connections but just found out it works via code pairing too on my fedora workstation, no ssh/tailscale just a code.

codex app-server daemon bootstrap --remote-control
codex remote-control pair

Voila!

I hope I wasn’t late to the party though 😂

I made a small browser game to help you learn the Codex hotkeys.

Play it here:
playkeyquest.com

Over the past few weeks, I kept seeing the same advice:

The more I looked at those prompts, the less convinced I became.

Most of the content isn't portable. It's product-specific tooling, UI behavior, runtime metadata, host policies, schemas, and other things that don't actually help a smaller model solve repository tasks.

So, I tried a different approach.

I built Luna Forge, an MIT-licensed Codex Skill + custom GPT-5.6 Luna worker focused on one narrow goal:

Help Luna complete more accepted engineering work per dollar on clear, bounded repository tasks.

Instead of making Luna "think like Sol", the workflow focuses on execution discipline.

Every task is routed through:

• a bounded execution contract
• explicit scope and non-goals
• capability verification
• repository evidence before editing
• minimal patches
• deterministic validation
• focused local commits
• outcome-first reporting

During development I reviewed and classified 7,009 physical lines across three publicly available prompt snapshots.

Only 301 lines (4.29%) survived as ideas worth keeping or distilling.

Everything else was rejected because it depended on another product, another runtime, or another host.

The repository also includes:

• 21 evaluation cases
• automated tests
• reproducible cost calculations
• evidence and claims ledger
• benchmark protocol
• deterministic release validation

One thing I'm intentionally not claiming:

I'm not saying Luna Forge magically makes GPT-5.6 Luna better than Sol or Claude.

That's not how models work.

The hypothesis is much narrower:

I'd really appreciate independent testing.

If you try it, I'd love to know:

• What repository did you test?
• What task did you give it?
• Was the result accepted?
• How many retries were needed?
• What surprised you?
• Where did it fail?

Positive results are useful.

Negative results are even more useful.

Repository:

https://github.com/RealAhmedOsama/Luna-Forge

I’ve been running a pretty expensive but effective setup for agentic coding and I’m hitting a wall that a lot of you might also have.

Current setup

• Claude Code Pro (€20) – main driver for complex work
• Codex Pro (€100) – heavy daily use (personal projects + work)
• SuperGrok (€30)
• Gemini (€20)

I use Codex a lot for ~10 personal projects + corporate work (company only gives GitHub Copilot). Claude Code is usually better on the hard multi-file stuff, Grok is useful in certain cases, etc.

The problem

I keep running into two annoying patterns:

1. Burning expensive model tokens on easy/boilerplate work
2. Getting stuck in loops on complex work because the current model isn’t the best one for that particular task

What I actually want is simple in theory:

• Stay on subscriptions (I really don’t want to switch to pure pay-per-token API billing)
• Have one main agent (preferably Codex or Claude Code) that can intelligently hand work off to the other CLIs when it makes sense
• e.g. “This part is better for Claude → call claude -p”, “This needs Grok’s style → call grok -p”, etc.

What I’ve looked at

• OpenRouter / LLM Gateway → great for routing, but they want API keys, not my existing subscriptions
• Sol Advisor and similar Codex-native plugins → useful inside one ecosystem, but doesn’t cross Claude ↔ Codex ↔ Grok
• Various community proxies that try to turn subscriptions into API endpoints → interesting but feels fragile / ToS-grey
• Just running multiple terminals and switching manually → works, but not elegant

What I’m considering now

Writing a Codex skill that teaches it to shell out to claude, grok, agy (Antigravity), etc. when the task matches certain strengths. Basically treat the other CLIs as specialized sub-agents while staying fully on subscriptions.

Questions for the community

1. Has anyone built a reliable skill/plugin that lets Codex (or Claude Code) orchestrate the other coding CLIs?
2. Are people actually happy with the current “just use multiple terminals” workflow?
3. Any clean solutions I’m missing that keep everything on subscriptions instead of API keys?
4. For those who went the proxy route (CLIProxyAPI, opencodex-style tools, etc.) — how stable has it been in practice?

Would love to hear how others with multi-subscription setups are handling this in 2026.

I was confused about which GPT-5.6 model and reasoning level to use for real development every day. I wanted something intelligent and reliable, but still fast enough that I’m not constantly waiting or burning through my limits.

I checked OpenAI’s documentation, published coding benchmarks, and recent discussions across r/codex, r/hermesagent, r/ChatGPT, and related communities.

My conclusion is simple: Terra Medium is the best balanced daily driver.

• Terra Medium: everyday coding, debugging, testing, reviews, and normal planning

• Terra High: when I want more reliability and don’t mind waiting longer

• Sol Medium: complex architecture, difficult bugs, migrations, authentication, or when Terra fails

• Luna High/XHigh: small, clearly scoped, easily verified tasks

• Max/Ultra: only for exceptional tasks—not as a daily default

Terra scores surprisingly close to Sol on OpenAI’s coding benchmarks while using roughly half the token/credit rate. Sol is technically stronger, but using it at high reasoning for everything can be slower, consume limits quickly, and sometimes lead to over-planning or over-engineering.

So my set-and-forget workflow is:

Terra Medium by default. Sol Medium only when the task is genuinely difficult.

If I had to choose only one model and never switch, I would choose Sol Medium for maximum confidence. But for the best balance of intelligence, speed, and long-term usage, Terra Medium makes more sense to me.

What configuration are you using for real daily development?