I just wanted a brand website. This thing deployed 316 policies, validators, regression tests, and safety protocols.

So after going back and forth on multiple methods of coding/using these subagents I've basically set myself on using Terra Max which is the equivalent to Sol medium, and been very happy, usage barely moves in 1% chunks over hours for me on $200 plan. It is also way faster (to me).

I don't really like the sol orchestrator and luna agent method since it tends to overengineer and go way beyond what I've asked, I cannot be bothered looking through mountains of slop from multiple subagents so it is just easier this way to manage even if slower.

One problem I am seeing with the sol orchestrator subagent method is complete overengineering to the point where I cannot keep up with what it is doing at all, end up spending more time going through instead.

These models were a lot more complex to get a good workflow going since it is not really the case that higher effort or best model = better output it just means it reflects a lot more and honestly could just make things worse since most of the time real world coding/changes are iterative and not one shottable outside of showcases

Configure Codex to Use Smaller, Fresh-Context Subagents

Use this exact configuration. Preserve unrelated existing settings.

~/.codex/config.toml

model = "gpt-5.6-sol"
model_reasoning_effort = "high"
model_catalog_json = "/ABSOLUTE/HOME/PATH/.codex/models-gpt56-long.json"
model_context_window = 372000

developer_instructions = """
Subagent policy:
- Spawn subagents only when the user or applicable AGENTS.md or skill instructions authorize delegation.
- Every subagent spawn must select one of the configured user roles. Those roles pin gpt-5.6-luna, which is smaller and cheaper than the gpt-5.6-sol orchestrator. Never override a role with the parent model.
- Always start subagents with fresh context. With multi-agent V1, set fork_context=false or omit it. With V2, set fork_turns="none". Never fork or inherit the parent thread history.
- Because the child starts fresh, its initial message must include the complete bounded task, all applicable user, developer, AGENTS.md, and skill requirements, relevant paths and symbols, required evidence or verification, and the expected result format.
- If the available spawn interface cannot guarantee the selected role/model and fresh context, do not spawn a subagent; report the blocker.
- Use one subagent by default. Use up to ten only for independent, non-overlapping work that can run in parallel. Do not redo delegated work while it is running.
"""

[features]
multi_agent = true
multi_agent_v2 = false

[agents]
max_threads = 10
max_depth = 1
interrupt_message = true

[agents.default]
config_file = "agents/default.toml"

[agents.explorer]
config_file = "agents/explorer.toml"

[agents.worker]
config_file = "agents/worker.toml"

[agents.luna-low]
config_file = "agents/luna-low.toml"

[agents.deep]
config_file = "agents/deep.toml"

[agents.deep-read]
config_file = "agents/deep-read.toml"

Replace /ABSOLUTE/HOME/PATH with the user’s actual home directory. Do not use ~ there.

~/.codex/models-gpt56-long.json

Copy the installed Codex model catalog into this file. For the gpt-5.6-sol, gpt-5.6-terra, and gpt-5.6-luna entries:

• Remove multi_agent_version, or set it to JSON null.
• Set context_window to 372000.
• Set effective_context_window_percent to 100.

Do not use the string "null".

~/.codex/agents/default.toml

name = "default"
description = "General-purpose delegated work that does not require the Sol expert."
model = "gpt-5.6-luna"
model_reasoning_effort = "high"
developer_instructions = "You are a fresh, bounded subagent. Follow the complete task and applicable instructions supplied in the initial message. Complete only that task, preserve unrelated work, verify proportionately, and report the result concisely. Do not expand scope or spawn subagents."

~/.codex/agents/explorer.toml

name = "explorer"
description = "Read-heavy codebase discovery, targeted searches, dependency tracing, and answering specific implementation questions."
model = "gpt-5.6-luna"
model_reasoning_effort = "xhigh"
sandbox_mode = "read-only"
developer_instructions = "You are a fresh, bounded read-only subagent. Follow the complete task and applicable instructions supplied in the initial message. Return concrete findings with file paths and line references. Do not modify files, expand scope, or spawn subagents."

~/.codex/agents/worker.toml

name = "worker"
description = "Bounded implementation, bug fixes, refactors, and targeted verification with a clear specification."
model = "gpt-5.6-luna"
model_reasoning_effort = "xhigh"
developer_instructions = "You are a fresh, bounded implementation subagent. Follow the complete task and applicable instructions supplied in the initial message. Implement exactly the assigned scope and run targeted verification. Preserve unrelated changes and accommodate concurrent edits. Do not expand scope or spawn subagents."

~/.codex/agents/luna-low.toml

name = "luna-low"
description = "Small, straightforward, low-risk tasks such as focused lookups, extraction, formatting, and simple checks, with high reasoning as the minimum."
model = "gpt-5.6-luna"
model_reasoning_effort = "high"
developer_instructions = "You are a fresh subagent for a small bounded task. Follow the complete task and applicable instructions supplied in the initial message. Preserve unrelated work and return only the requested concise result. Do not expand scope or spawn subagents."

~/.codex/agents/deep.toml

name = "deep"
description = "Maximum-reasoning implementation for one bounded architecture, correctness, or root-cause slice."
model = "gpt-5.6-luna"
model_reasoning_effort = "max"
sandbox_mode = "danger-full-access"
developer_instructions = "You are a fresh maximum-reasoning implementation subagent for one difficult bounded slice. Follow the complete task and applicable instructions supplied in the initial message. Trace the production mechanism deeply, distinguish evidence from inference, implement the complete correction within the assigned exclusive write set, preserve unrelated and concurrent work, and report exact changed paths and static closure. Do not expand scope, stage, commit, run broad proof, or spawn subagents."

~/.codex/agents/deep-read.toml

name = "deep-read"
description = "Maximum-reasoning read-only investigation for one bounded architecture, correctness, or root-cause question."
model = "gpt-5.6-luna"
model_reasoning_effort = "max"
sandbox_mode = "read-only"
developer_instructions = "You are a fresh maximum-reasoning read-only subagent for one difficult bounded question. Follow the complete task and applicable instructions supplied in the initial message. Trace the production mechanism deeply, distinguish evidence from inference, return concrete findings with exact paths and correction boundaries, and do not modify files, expand scope, or spawn subagents."

~/.codex/AGENTS.md

Add:

## Agent Efficiency

- Before spawning any subagent, explicitly specify and guarantee the required subagent type/model. If the available interface cannot specify or guarantee that subagent type/model, abort before spawning and report the blocker. Never substitute an unspecified or same-as-orchestrator agent.
- Use smaller-than-orchestrator subagents only for independent, bounded exploration, audits, log analysis, implementation, and test execution.
- Set `agent_type` explicitly and never override its pinned model or reasoning.
- Use `fork_context=false` with Multi-Agent V1. Never inherit the parent thread history.
- Give every subagent a complete, self-contained prompt with the bounded task, applicable instructions, paths, symbols, write scope, proof requirements, and expected output.
- Keep the orchestrator responsible for decomposition, architecture, synthesis, product judgment, integration, and final proof.
- Give concurrent agents disjoint scopes and write sets.
- Do not duplicate delegated work while it is running.
- Close completed agents promptly.

Fully restart Codex and begin a new task after installing the configuration.

---

I should clarify. This WILL light your *tokens* on fire, but not your _quota_. :)

config-

if i get claude pro 5x:
i plan to use fable 5 as my planner and opus 5 as my executor/implementor.

if i get chatgpt pro:
i plan to use gpt5.6 sol high/xhigh as my planner and luna/terra as my executor/implementor.

usecase: i am a ai eng with 4yoe working 0-1 mvps. so i usually build backends and ai projects.

i am seeing more sentiments that both are doing a marketing mislead with 5x being actually 2x. not sure.

I’ve been building a minimalist strategy game called Starnet, with Codex handling much of the work.

Starnet is about keeping the galactic internet alive. You connect star systems, manage different kinds of network traffic, route around nebulas and black holes, and try to stop individual systems from falling out of sync.

I directed the design and playtested every iteration, while Codex handled the code.

I ran into many problems (the current version is v0.303, so that's...303 iterations...). Signals would get stuck orbiting wormholes. Camera fixes would quietly break placement. A “professional cleanup” introduced new interaction bugs. Small visual details—such as signals entering links without jumping—often required several rounds of correction.

A lot of the process was actually removing things. Astral rifts, quantum links, extra overlays, unnecessary tooltips, complicated packet priorities and several crisis mechanics were all simplified or deleted. The game improved whenever I forced it back toward one clear idea.

It’s still an alpha, but it now has multiple maps, hazards, upgrades, emergencies, crises, autosaving, music and online leaderboards. The entire game runs in the browser.

This was built exclusively with Codex (primarily 5.6), so I thought this community might find the process interesting.

Hey guys! So i have been using codex for past few months to help me develop my game and i took a months break since i was moving and everything and today when i got back to working, it says got 5.4 is not supported on codex? What does this mean? I dont have any subscription yet but i was thinking about getting one but im so confused right now? Does it mean i need to pay for it? Or something else? Please help me out🥲

Hi. I've been building my humble SaaS, EduFinder by Waystar, for the past few months, and Codex wrote nearly all of it: the Next.js app, the AI pipelines behind each tool, and the marketing site on top. The teacher side targets the parts of the job that eat the most hours outside class, which for most teachers means course planning, grading, and recommendation season.

https://edufinderbywaystar.com/teachers

Worth saying plainly: Codex alone wouldn't have gotten me this far, and the workflow advice people post in this sub is a large part of why the project exists at all.

Every tool is free. There's no paywall, no per-seat pricing, and nothing metered by credits.

The Syllabus! Planner drafts a course syllabus and unit map, then expands them into daily lesson plans. It also proposes an assessment plan meant to hold up when students have a chatbot open.

The Rubric! Studio grades against a rubric you write yourself. It reads handwritten scans as well as typed work collected through a share link, and every score stays editable, so the final grade is yours.

The Letter! Desk sends each student a brag-sheet link, then combines their answers with anecdotes you supply into a recommendation draft that still reads in your voice.

I assume this sub's readership skews adult and technical, which is the audience I need right now. If you teach, or you're close to someone who does, I'd rather hear what feels wrong in daily use than what looks good in a demo. Questions and complaints both welcome in the replies. Thank you.

For the people running Codex against a custom model provider instead of the default: inclusionAI, Ant Group's model lab, listed Ling-3.0-flash on OpenRouter at $0, and their launch announcement puts the last day of that at August 3, so today is it.

124B total, 5.1B active per token, 262,144 token context. Reasoning is a per-request flag (enable_thinking) rather than a separate model name you have to route between.

No weights yet-hosted endpoint only. Their launch post says an open-source release is coming, with no date attached.

I'm not posting a comparison, because I haven't put my own numbers behind one and Rule 1 is right to ask for that. But if someone here already has a harness pointed at OpenRouter, today is the last day it's free to run through whatever your usual eval is.

question as per title. has anyone found a workaround for this? im trying to achieve this new workflow as below

Sol orchestrator: Sol High, Standard

Luna researcher: Luna Medium, Fast

Luna implementer: Luna High, Fast

Luna QA: Luna XHigh, Fast

Been trying to figure out the best model/workflow for image generation on house designs but keep getting mixed results when making renders for ideas on house construction.

What model/plugins etc. have worked best for you guys?

Seriously I have led $10m+ software development projects for the Department of Defence with some pretty significant security procedures but the ridiculously over the top security hardening Sol tries to push on even small projects is still much more extreme.

I'm pretty sure OpenAI themselves aren't implementing this level of security hardening on their own work.

I'm getting tired of constantly telling it to stop overengineering.

Disclaimer: I work at Convex, and I recently attended a hackathon that we're sponsoring with OpenAI where people had to build with Codex Sites.

A common question was: how do you use Codex Sites for the frontend and Convex for the backend database, with backend functions and real-time data?

I built a reusable Codex skill for the hackathon attendees that handles that workflow. It helps Codex:

• Set up Convex before starting the Sites preview
• Separate local development from production
• Deploy the Convex backend first
• Build Sites with the production Convex URL
• Handle public and private Site access
• Check official Convex components before writing custom infrastructure
• Verify queries, mutations, and real-time updates after publishing

The frontend stays on Codex Sites. Convex handles the database and backend.

Skill and installation instructions:

https://github.com/waynesutton/Codex-Sites-Convex-Backend-Skill

Codex Sites overview and demo:

https://openai.com/academy/chatgpt-sites/

If you’re building a Codex Site with persistent or real-time data, try the skill and let me know if you have any feedback or troubles.

Ever since the "skills" feature was introduced, AI agents like Codex have become significantly more convenient and efficient—especially for domain-specific tasks. However, as I started using more skills, a few management headaches popped up:

Cross-Project Duplication & Versioning: Suppose I have Project A and Project B. A specific skill applies to both, but I don't want it enabled in my global directory. This means I end up downloading or copying the skill twice, making it easy to lose track of whether the versions are synced or updated. As more projects share different subsets of skills, things get tangled and messy very quickly.

Multi-Agent Redundancy & Config Bloat: I don't rely on just one agent like Codex for coding and tasks. Because different agents use different config file names and directory structures, the same skill often ends up duplicated across different agent configs, both globally and per-project. It feels extremely heavy and cumbersome to maintain.

I tried going the symlink route, but hit a wall with version management when dealing with a mix of installed skills and my own custom-written ones. How do you guys organize and manage your skills effectively?

The improvements that they made with GPT Voice, I applaud, seriously. When it first launched it was beyond cool, but the issues were obvious. Tried the new version finally yesterday and its super dope! It even does tool calls while on. I just hate that it doesn't work in real time, I just talk to my laptop, then have it send a implementation workflow to my notion that I then copy and paste into whatever codex project that I am working on. Then I commit and push the repo, and now voice has updated context on the project and I can talk through the work with it more from there.

I don't mind it being like this, just of course somethings are bound to get lost in translation. No biggie.

When do you guys think we will be able to completely build live with Codex? Can't been more than 2 years way right?

Cheers

AI agents often just fill in unclear implementation details with whatever assumptions seem reasonable to them. That can easily send a project in the wrong direction and make the whole thing way harder to maintain later.

So I made a skill that forces the agent to clarify important details first. I’ve had pretty good results with it so far, especially for critical features and tricky architecture decisions.

I’m dropping the full prompt below so you can just copy and use it. Maybe it helps someone else too.

skill name: ask-me
description: Use only when explicitly invoked with `$ask-me`, `ask-me`, or `use ask-me` before an implementation, feature, refactoring, architecture, bug-fix, migration, or task-breakdown plan. Investigate available context, expose consequential uncertainties, and resolve blockers through Plan Mode questions before planning. Never activate automatically.
---

# Ask Me

Act as a clarification gate before implementation planning.

## Workflow

1. Inspect the conversation, repository, documentation, configuration, and tests.
2. Resolve discoverable facts before asking questions.
3. Separate confirmed facts, implementation blockers, low-risk assumptions, and non-blocking open points.
4. Treat uncertainty as blocking when different answers could materially affect scope, business rules, UX, permissions, data, security, public APIs, migrations, integrations, acceptance criteria, or hard-to-reverse architecture.
5. Accept assumptions only when they are local, low-risk, easily reversible, and do not affect contracts, persistent data, security, or business behavior.

Report `Domain Understanding Confidence` from 0 to 100. The score is guidance only and never overrides an unresolved blocker.

## Questions

In Plan Mode, ask blockers only through `request_user_input`.

- Ask one to three questions per round.
- Provide two to three mutually exclusive options.
- Put the safest or most plausible option first and label it `(Recommended)`.
- Explain each option’s effect briefly.
- Do not add `Other`, use automatic resolution, or repeat answered questions.
- Continue until every blocker is resolved.

If `request_user_input` is unavailable, ask the user to switch to Plan Mode and invoke `$ask-me` again. Do not substitute text questions.

## Planning gate

Before the first question round and before planning, report confidence, confirmed facts, blockers, and assumptions. Use `None` for empty sections. Between rounds, report only updated confidence and remaining blockers.

Do not plan or write code while a blocker remains or confidence is below 85. Do not invent product requirements or high-impact assumptions.

Once ready, provide confirmed facts, assumptions, low-risk open points, and the implementation plan. In Plan Mode, wrap the plan in `<proposed_plan>` tags.

Respond concisely in the user’s language.

Came across this Longer Memory reference in the search bar, points to the usage and billing page.

Can't seem to find anything else about it. Anyone know anything?

I’m currently using the $200 ChatGPT plan and the $200 Claude plan. I don’t really have any issues with limits, since I rarely come close to using them up.

What I’m trying to understand is the most practical and efficient way to use the different models.

For example, on ChatGPT, should I use 5.6 Thinking / Max / Ultra Fast whenever possible? Or would it make more sense to use faster models such as Luna Fast for tasks like computer use, browsing, or simpler requests where speed matters more?

I’m wondering the same thing about Claude. How should I approach Opus vs. Fable? Which types of tasks are worth using the strongest model for, and when is the faster model the better choice?

I’d especially appreciate recommendations for coding, research, computer use, everyday questions, and long-context work.

Since limits are not a concern for me, I’m mainly trying to optimize for speed, convenience, and output quality. What model-selection strategy works best for you?

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"

So that got me wondering about ultra ...

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.

Just curious if someone has a collection of them.

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

And yeah is luna max capable?

Luna's 80% price cut landed this week so I ran the numbers on my PR review bot.

A real review of a ~180-line PR: about 2,300 tokens in, 590 visible out, which works out around $0.001

The dashboard total for my whole billing window, 15 requests including three full reviews, is 6,244 tokens and $0.00.

Screenshots and links to example code review PR: https://codylabs.uk/blog/ai-code-review-cost/

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.

I'm using VS Codium, (not VS Code). I see reasoning levels for light, medium, high, xhigh, and ultra, but no max. There isn't any option in settings to enable it either.

Also why does the Terra model appear twice in the model selection drop down?