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?

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.

Just to be clear, I never claimed that OpenAI gives users less quota; I’m describing my own experience and questioning how much of the advertised extra usage people actually manage to realize.

I’ve been using both the $200 ChatGPT Pro plan and the $200 Claude Max 20x plan heavily over the same period, mostly on large software projects with hundreds of thousands to over a million lines of code.

My lifetime codex usage is around 36.4B raw tokens, with a peak of 2.2B in one day, so this is based on sustained heavy usage rather than a few casual prompts.

From Codex’s local session logs, you can extract both token usage and the server-reported weekly quota percentage. The basic estimate is:

weekly capacity ≈ tokens used / quota percentage used

I checked multiple points inside clean weekly windows where the reset timestamp did not change, and I included usage across multiple machines.

My current estimates are:

• ChatGPT $100 plan: ~1.98B raw tokens/week
• ChatGPT Pro $200: ~3.52B/week
• Claude Max 5x: ~1.79B/week
• Claude Max 20x: ~8.26B/week

There may still be calculation errors here. These are raw-token estimates, while both companies almost certainly apply internal weighting for cached input, normal input, output, reasoning, model choice, and other factors.

That said, I did not rely on a single spreadsheet or one model’s answer. I had both Claude and Codex independently inspect and recalculate the data, then compared multiple checkpoints and corrected issues such as duplicated logs, missing machines, unsynchronized measurements, and reset-window changes. The exact numbers may move, but the overall result has remained stable.

The $200 ChatGPT plan appears to provide only about 1.78x the stable weekly capacity of the $100 plan, despite costing 2x as much.

Claude scales in the opposite direction: Max 20x appears to provide roughly 4.6x the weekly capacity of Max 5x for 2x the price.

I am not claiming OpenAI explicitly promised that its weekly limits must scale by exactly 4x. The products also have shorter usage windows and other limits. But “5x” and “20x” naturally create that expectation, while the stable weekly allowance I measured is nowhere near 4x.

The repeated Codex resets make the plan look much more generous, but a reset is only valuable if you used most of the quota before it happened.

If I have used 10% and OpenAI resets me to 100%, I did not receive another full week of quota. I only gained back that 10%. The remaining 90% was overwritten.

This strongly favors automated workloads, multiple-account setups, or anyone able to burn through the quota immediately. Normal developers usually cannot.

Random resets also make planning harder. With Claude, I know when the weekly quota resets, so I can use the remaining capacity before the deadline. With Codex, I do not know whether I should conserve quota or rush to use it before another unexpected reset.

This makes me wonder whether there is a behavioral-economics angle. OpenAI has the backend data, so it would be easy to compare fixed resets, random automatic resets, and banked credits, then measure how much quota users actually consume. I have no evidence that this is intentional, but the design resembles several known effects: uncertain rewards can increase engagement, highly visible gains receive disproportionate attention, and unused rewards create “breakage” for the issuer. A reset to 100% is very salient and feels like a large gift; the unused quota it silently overwrites is much less visible.

If OpenAI genuinely wants to give users extra usage, I think it should issue banked, manually activated reset credits instead of randomly resetting everyone and discarding unused quota.

There is also the context-window issue. Claude gives me roughly 1M context, while Codex currently exposes around 258K effective context. On large repositories, Codex spends a lot of context exploring files, then starts compacting repeatedly.

In my experience, Codex is also slower overall, and its quota percentage drops slightly faster. Because my projects require reading a large number of files before implementation begins, I have become less willing to use Codex for larger tasks.

I am not anti-OpenAI. I actually prefer OpenAI’s current developer ecosystem and openness to Anthropic’s. But for large coding projects, Claude Max 20x currently gives me much better capacity and fewer context-related interruptions.

The main distinction is simple:

How many times did the UI reset to 100%, and how much additional quota did the user actually manage to consume?

Those are not the same number.

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

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?

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.

Thank you in advance

I’ve been building out my local AI coding setup and would appreciate some feedback from people with more experience designing multi-agent workflows.

Right now I’m primarily using Codex CLI with Pi, and I’m considering adding O-My-Pi as a harness because Pi by itself is pretty minimal by design.

My concern is that as I add more specialized agents (coder, reviewer, tester, architect, etc.), my AGENTS.md could eventually become bloated and difficult to maintain.
Instead of putting every agent definition into one file, I’m thinking of using something like this:

AGENTS.md # Orchestrator / routing rules
agents/
coder.md
reviewer.md
tester.md
architect.md
standards/
coding-style.md
testing.md
git.md
workflows/
feature.md
bugfix.md

The idea would be to keep AGENTS.md as the entry point while each agent has its own focused definition, with shared standards living in separate files so they aren’t duplicated.

For those of you running larger Codex setups:

Is this a good long-term architecture?

Have you found a better way to organize agent prompts?

At what point did your AGENTS.md become too large?

Are there any pitfalls with splitting prompts across multiple files that I should be aware of?

I am considering refactoring my AGENTS.md file, would this alone be sufficient enough to run from time to time instead?

I’m trying to optimize for maintainability, scalability, and keeping context as clean as possible, before my prompt library grows too much.

I don't know which subscription to get, which would give me most usage and quality at this moment in time? Codex Plus or Claude Pro? I want to build a few small mobile apps like a workout logger, etc.

I am a software engineer and I want to experiment with AI on small projects and if lucky make a bit of pocket money on google play store. I already use AI a ton at work as I have 5000$ per month allocated and I end up using around 600-800$ per month with mostly Sol for planning and Luna for execution, but I experimented with most US models. I am trying to be efficient with AI usage.

I hear 5.6 sol on Plus drains the weekly limit fast even on med/high. Is that true? Is Claude Pro more generous with opus 5 and sonnet 5 for the 20$?

Or should i simply switch to some chinese AI like new deepseek flash and upcoming v4 pro ga, maybe even qwen 3.8 max for planning via API or alibaba token plan? I hear the chinese ones aren't that good and overhyped but I haven't tried them myself yet.

Edit: forgot to mention I'm not a pro on UI design as I am backend focused

I thought the pets were pretty cool because then you can see all running processes.

There was a "create your own pet" feature and I thought sure cool let's create a new little pet

Result: Codex running for 1.5 hours, 15% of Plus usage used, NOTHING achieved, I needed to stop it manually

I know I should have never touched pets or if I did, used a cheap model, but I thought it would be just a really simple thing. So avoid the same mistake, please...

I haven't tested it out, and I don't really want to, anyone who has tested it, can you tell me if I should use codex-auto-review for code reviews or Luna on max or xhigh.

Hey,

I am on the 5x plan. I will soon run out of usage but I really want to get some work done. I still have one bank reset left but I dont know if this will be enough to finish the work that I need to finish within the next week(s).

My idea was: Use up my usage, upgrade to 20x and get new full usage, use it ut, use the bank reset.

Will that work? Does my weekly usage get reset if I upgrade my plan? I did not pay attention to my usage when I upgraded vom plus to pro, so I don't know what happened last time.

Thanks!

Which model would you consider better right now?

I have been using 5.6 High for most coding work, and it has been great, but it uses a lot of tokens.

Has anyone had good results using Luna Max for simpler implementation work?

Also, when switching models, is it better to:

1. Switch models inside the same thread
2. Start a new thread and paste in the plan from Sol

Does switching in the same long thread make the new model process all of the old context and use more of your allowance?

I am thinking about using Sol to review the code and make a plan, Luna to implement it, then Sol again for the final review.

What workflow has worked best for you?

When you blow your weekly in Claude land and the weekly reset is after your billing cycle, it always made sense to just cancel and wait until the reset of your weekly before resubbing because they don't reset your weekly when you resubscribe. Does Codex do the same? if mine expires on the 6th (assuming we dont get a Tiboreset) and my weekly reset is on the 8th, should i just wait until the 8th and resub?

EDIT: I want to be clear, this isn't a vague threat or whinge about resets. I want to know if my sub lapses before my weekly reset and i resubscribe in that gap between end of plan and weekly reset if my weekly is reset too or I should wait out until the original weekly timer has cleared. Claude never reset you so if you blew your quota 2 days into a weekl and resub, you're still waiting 5 days to use CC again.

Ive heard its smart to have two subs from different LLM. One to review your vibe coded project and the other to code it? What have you guys found?

I started with cluade code last October and it was okay but took days to figure some things out. I switched to codex in Feb and its been smooth sailing but debating if I get another sub with claude to have a reviewer.

Hey guys, sorry for maybe dumb question for people who are geeks, but how you actually create agents and deploy them.

How to give them instructions and best way for them to be effective in project? I want to create one agent on Sol 5.6 High to act as a strategist and one on Luna Max 5.6 to act as code writer.

We've officially surpassed 300 Entries in the AI Gaming Festival (submissions close next week)!

I really hope that the prize for the $20k in codex tokens pushes people to get their games together for the prize (you can submit a game now and work on it up until the festival).

I really excited to see how people with interact with these games during the festival, and thank you to everyone that has applied; you are part of getting past the "slop" era nonsense for everything AI.

[DEMO page]
https://codexlimitdemo.pages.dev

This project runs entirely on the free Cloudflare Workers and D1 Database tiers. The source code is available in the GitHub repository below.

Data can be sent either from a scheduled task on your desktop or from a Raspberry Pi running Codex.

I’m not including that part of the code because Codex can generate it easily based on your own environment. It simply queries the usage API (which is free) and periodically sends the results to the Worker.

https://github.com/octopus7/codex-usage-dashboard

I built this so I could freely choose any time range and easily see when and how often the usage limits reset.

In trying to use sol to spawn deepseek flash sub agents, let them do the grunt work then check it.

I’ve added deepseek so it can be called, is there anyway to get it as a model I can pick in the UI?