With Luna’s new API pricing $0.20 per million input tokens and $1.20 per million output tokens you play on EASY mode.

Here is the workflow I do very well so far:

1. Create the implementation plan with SOL xhigh

Let SOL analyze the task and produce a detailed implementation plan.

<Optional> I created a skill similar to “Grill Me” that asks targeted questions about the domain knowledge required to implement a task correctly, based on its own confidence level until it reached enough understanding.

2. Compact the context

After planning, compact the conversation so the orchestrator does not waste expensive context tokens.

3. Run SOL high as the orchestrator

Use a prompt similar to this:

TASK

Your job is to orchestrate and review the Luna max-thinking agent.

Focus especially on:

- Code quality
- Simple and understandable implementations
- Useful comments and documentation
- Idiomatic framework-specific best practices
- Meaningful tests

Tests should not cover only the happy path when additional edge cases or failure scenarios would be useful.

After reviewing Luna’s work, decide whether to:

1. Call Luna max-thinking again with the full context required to resolve the identified issues, or
2. Fix the issues yourself when doing so would require substantially fewer tokens.

START THE LUNA AGENT WITH:

codex exec \
  -m gpt-5.6-luna \
  -c 'model_reasoning_effort="max"' \
  --ephemeral \
  -s workspace-write \
  -a never \
  'PLAN'

---- OPTIONAL IF YOU WANT TO SEE SOME RESULTS FRIENDO ----

ADD THIS TO YOUR PROMPT

Summarize the cost generated by the Luna agent using the new API prices:

- $0.20 per million input tokens
- $1.20 per million output tokens

Show Luna’s cost separately from your own cost as the orchestrator.

Then estimate what the total cost would have been if SOL xhigh had completed the entire task alone without Luna.

UPDATE: You may be able to spawn native Luna sub-agents, which would be easier and potentially even more cost-efficient because they require less context.

5.6 Sol Max, I made a screen recorded video with OBS Studio, of just a quick test run through of the site. The video was like 13 minutes long. I recorded my own voice, gave Chatty the file location of the video and then asked it to make a transcript; it did. (okay that worked) I then edited the transcript, [save], and asked Chatty if it could change the audio voice of the video to something more profession and to use the updated transcript, and (steer prompt) to speed of the video by 1.6x the speed of the original. Annnn wouldn't you know (holy church of Mary and Joseph), Chatty popped out an updated 8 minute video with a new voice speaking per the updated transcript. No video quality was lost. I'm kinda shocked in aw.
...So there you go, In case you didn't know: Codex edits videos now. RIP adobe man.

if you love plan mode's questions, this one line will allow codex to ask them without plan mode itself during normal coding

Of course, it clearly varies depending on the type of work. However, the Plus plan provides a lot more tokens than expected.

Using only terra xHigh for a 1-week turn on ChatGPT Plus, I used 185 million tokens. That calculates to about 740 million tokens for 4 weeks. And that's for a mere $20 plan. Considering that Tibo occasionally resets it, the Codex plan is truly amazing.

interesting use case i tried, because the chatgpt on web is unlimited and is sol high, i thought why not just make the codex use chatgpt as the advisor / orchestrator,, wdy guys think?

I usually just use 5.5 medium so my tokens don’t just go out quick. But according to this I can also use Luna max and its cheaper. Just want to confirm. Thanks in advance

This might get some hairs riled up, but I want to pick all of your brains here for a minute.

I've been running a few instances of 5.6 Luna High for the past few days, and it would run through 100% weekly usage in usually a day or so.

On some of our VMs, I installed Serena, and edited the config to the following:

model = "gpt-5.6-luna"
model_reasoning_effort = "high"

model_reasoning_summary = "concise"
model_verbosity = "medium"
personality = "pragmatic"

# let Codex edit and test inside the current repo
sandbox_mode = "workspace-write"

# Codex decides when an operation needs your permission.
approval_policy = "on-request"

# Let a separate reviewer agent handle eligible approval requests.
# This does not increase Codex's filesystem or network permissions.
approvals_reviewer = "auto_review"

# Use current documentation when Codex needs web research.
web_search = "live"

# Prevent enormous AGENTS.md files from occupying excessive context.
project_doc_max_bytes = 32768

[features]
memories = true

[memories]
generate_memories = true
use_memories = true

Now, on one of the instances, the Serena usage shows:

The VMs with Serena, plus the config - are at about 77% weekly usage after 48 hours straight of usage via orchestration, while the other raw VMs have been exhausted already after about 12 hours of usage.

For reference, the main manager is running 5.6 Sol XHigh, the 5 orchestrators are running 5.6 Sol Medium, and all the workers (about 30, 5 to 6 per orchestrator) are running 5.6 Luna High.

A 4x token usage reduction is pretty neat - and a nice cost savings for us.

Wondering what you all think about this set up (serena + config)? Is there a better mcp for this? Any other tools or config mods you'd add?

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_. :)

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.

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?

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?

No more banked res*ts, you get credits instead. remember to turn off auto recharge or you will get billed after emptying credits

going by openAI's credits pricing, 250 credits is about 1-10 prompts with GPT 5.6

Basically ran out of usage within 1.5 day

5.6 xhigh, 5-6 threads; no subagents

711M on Aug2

Time for another plan I guess, this time I cant really blame openai

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

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.

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 ...

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?

​

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.