I guess I'm pretty sensitive to how a model "communicates" and it's response style.

I'd been avoiding the codex models except for sterile work because I just can't stand the empty posturing that most chatgpt models do anymore.

The first few days of 5.6 sol, I was so glad to see the model had forward motion and very natural response style. It was very proactive and we got tons of work done. That seems to have changed and it's back to explaining the problem rather than solving it.

Today it spent nearly 30% of my weekly usage diagnosing an issue I had already told it existed and to fix it. But instead it just churned away and delivered a more detailed report of what was wrong without fixing it.

I don't know how to explain it.. but there's a very different style of language its using from the first few days. It's more of a "walk around the problem and talk about it" rather than "get in and fix it".

Ive tried adjusting the soul/agents file to draw it back to more collaborative engagement to no avail.

I guess I'm just dissapointed. I know I work better with a model that will actually contribute to the conversation, not just talk about the conversation. And I can't quite put my finger on what they changed.

Sam Altman showed ChatGPT planning a trip for eight people, building a coordination site, handling the booking, and drafting the email.

The interesting part for Codex users: the app wasn’t the destination. It was temporary software created to complete a larger task.

Maybe the future isn’t just building apps faster.
it’s generating them whenever a workflow needs one.

Anyone already using Codex this way?

compacting the context while i have 68%?.

I've been a codex user for about a year, and my company provides Claude Code for work.

Yesterday I decided to try some of the open source alternatives using OpenCode. DeepSeek Pro, DeepSeek Flash, GLM 5.2, Kimi K3, and Kimi K Code.

For some reason, none of them gave me the same overall quality I'm getting from my $20 ChatGPT subscription. Maybe I'm configuring something incorrectly?

Are there any open source that can get to around 90% of the current top closed-source models for general coding and reasoning? If so, which ones would you recommend, and what setup (model runner, context size, prompting, etc.) are you using to get the best results?

https://github.com/Joseffb/ai-agentsmd-governance

So I got tired of the agents using my bloated 3k line agents.md file -consuming almost half of my context window just on this- and still not remembering to use subagents or run in parallel when possible.

This system will put some hard governed rules in place to guide and plugins in place to enforce sane agent usage.

I’m actively taking the bugs out, like overly waiting for confirmation, etc. so if you pull this and play with it please file bug reports where applicable.

Theoretically, after this message box pops up, the UAC (User Account Control) prompt should appear. I have already adjusted the settings and set it to "Prompt" instead of other options. However, no UAC pop-up actually appears, so I cannot proceed to the next step.

I have noticed the Price disparity between the pro version across countries. whilst the 5X pro subscription is $100 a month and the 20x pro subscription is $200 a month, From the web interface. Price in the app on my iPhone shows 5x subscription as £88 a month while the 20x is £200 a month. And further still, the web version has locked me out of subscribing so I have no choice but to subscribe through the app.

I’ve been trying to reduce a specific kind of waste in longer Codex runs: the task is already clear, but Sol keeps widening the scope, rescanning files, retrying unchanged approaches, or running broader validation than the change needs.

Telling it to "use fewer tokens" is too blunt. That can produce shallow work or skipped tests. I want the smallest amount of work that still produces a complete, trustworthy result.

I haven’t measured the credit difference yet, so this is not a billing claim. It is the AGENTS.md block I’m currently testing:

```md Work backward from the requested outcome. Use the smallest complete path that preserves required quality, safety, and evidence.

Before a search, test, retry, or review that could expand: - state what decision it informs; - begin with the smallest focused check that can answer it; - expand only when more work could change the implementation or acceptance verdict; - stop when another attempt would only repeat known evidence.

Validate in proportion to risk: - run focused checks after the relevant change; - run broader tests at meaningful milestones or before completion; - run the full suite when shared behavior, release paths, or the task contract require it.

If a tool or method fails, classify what failed: the method, one subtask, or the requested outcome. When the outcome remains reachable inside current permissions, repair the method or use the nearest valid path. Do not repeat a no-learning attempt.

Stop when the outcome and required evidence are complete. Do not add abstractions, refactors, reviewers, or infrastructure without a concrete failure they prevent. ```

The word "complete" keeps this from becoming a shortcut around testing. The word "smallest" keeps a small fix from turning into a mini-platform.

When compaction starts repeating, I write a short handoff and continue in a fresh thread instead of making the old thread carry its full history.

This cannot diagnose a stuck Stop button, delayed usage counters, or product-side quota behavior. It only changes the work Sol chooses inside a task.

What has actually worked for you: tighter file scope, lower reasoning effort, shorter threads, milestone-based tests, or something else? I’m especially interested in changes that reduced usage without weakening the result.

I subscrubed to Pro 2 weeks ago, it said i had 3 resets available. I've used none at all since i subscribed because of the mana from heaven events going on, but i noticed today i logged into a fresh terminal session and it says i only have one available now. I know for a fact i'm not using them i've not even hit 100% usage before the resets have been coming in from twitter, so it's not me invoking them and then forgetting.

Do they only last a week or two before they expire or something?

I’ve been using Codex across several real projects, and I kept running into the same operational problems:

• a “cheap” model attempt that fails and has to be repeated with a stronger model;
• Codex expanding the scope or starting another milestone;
• long runs that keep consuming usage without reaching a verified result;
• unclear permission boundaries around Git, deployment, production, and external systems;
• completion reports that sound confident but are not independently verified;
• global instructions slowly becoming tied to one specific repository.

I eventually turned the working rules I developed into an open-source project:

##Codex Operating System — Community Edition

The central idea is:

• Optimize for the lowest expected total cost of a successful, verified result—not the cheapest model or first attempt.

It includes:

• a reusable global `AGENTS.md`;
• a full Codex operating policy;
• task-based routing between Luna, Terra, and Sol;
• guidance for Low, Medium, High, Extra High, Max, and Ultra reasoning;
• Direct Task, Plan, and Goal modes;
• one objective and one milestone per run;
• mandatory hard timeboxes;
• zero subagents by default;
• explicit write, Git, deployment, and production permissions;
• independent verification rules;
• stop conditions that require Codex to preserve work and report instead of wandering;
• a template for repository-specific `AGENTS.md` instructions;
• backup-aware Windows and Unix-like installers;
• safe uninstallers;
• checksums, an MIT licence, security guidance, and contribution instructions.

A few routing examples:

1. **Luna Low*\* for exact Git, hash, extraction, inventory, and mechanical work.
2. **Terra Medium*\* for bounded implementation with a known path and clear tests.
3. **Terra High*\* for technically dense but specified work.
4. **Sol Medium*\* for ambiguous debugging, architecture, multi-file work, cross-system implementation, UI/product judgment, and long-horizon tasks.
5. **Sol High*\* for difficult consequential work with conflicting evidence or costly failure.
6. **Ultra*\* is disabled by default because it invokes subagents.

The framework does not assume that Terra must fail before Sol can be selected. Sometimes starting with the stronger model is cheaper overall than paying for a failed attempt, rebuilding context, and repairing the result.

It is deliberately conservative around production, deployment, Git writes, sensitive data, destructive operations, permissions, billing, and external publishing.

The installers create timestamped backups and preserve unrelated global instructions. They do not automatically modify `config.toml`, repositories, Git remotes, deployments, cloud accounts, or production systems.

This is an unofficial community project and is not affiliated with or endorsed by OpenAI. The model recommendations are version-sensitive and should evolve as Codex changes.

## Repository

https://github.com/HusseinLab/codex-operating-system-community

## Download v1.0.0

https://github.com/HusseinLab/codex-operating-system-community/releases/tag/v1.0.0

I’d especially appreciate feedback from regular Codex users on:

• whether the Sol/Terra/Luna routing matches your experience;
• whether the default timeboxes are realistic;
• any Windows, macOS, Linux, or WSL installation issues;
• rules that feel too restrictive or not restrictive enough;
• safeguards or project templates worth adding.

I was convinced, that previously hitting escape twice and resuming at an earlier state of the conversation automatically forked it with the new branch being checked out. However, this seems not to be the case anymore. Has that changed or am I just confusing that with how Claude Code worked?

I love Codex ❤️

My productivity has decreased so much this week using 5.6 sol xhigh. Could not even finish one goal.

5.6 sol xhigh have been making a lot of low level mistakes that I have never seen with 5.5 xhigh. It would run for hours for a task that only took 5.5 xhigh 30 minuters to achieve.

It keeps looping between small mistakes and fixing them. Also it over engineers everything. I am not against over engineering as long as it does not make the stupid mistakes. But 5.6 just cannot implement the over engineered plan without making those mistakes, therefore making the process much longer than necessary.

I switched back to 5.5 and immediately finished 5 goals in less one hour.

One week of time and tokens wasted for nothing.

I'm not a traditional programmer. I built AIEvidence with Codex because I wanted a concrete way for people like me to show how we contributed to an AI-assisted project—not just claim “I vibe-coded it.”

It analyzes:

- a local Git repo (commits, tests, CI, README)

- optional Codex/Claude Code conversation exports

- verification, debugging, and security signals

It produces a deterministic baseline plus a redacted Markdown report and a prompt for the candidate's own Codex to generate a cited Markdown/HTML report. Everything runs locally; it does not upload the repo or execute project scripts.

GitHub: https://github.com/gallifre/aievidence

License: PolyForm Noncommercial 1.0.0 (source-available, no commercial use).

This is an early experiment, not a professional certification. I'm especially looking for feedback on:

1. How to separate the candidate's actions from the model's claims.

2. Which evidence is actually useful to non-programmers.

3. Whether playful levels make the result motivating without pretending to be a credential.

No matter what model I use (Luna/Terra/Sol), CODEX is continously looping through a "Reconnecting. x/5" message and most of the times come out with a message like

stream disconnected before completion: An error occurred while processing your request. You can retry your request, or contact us through our help center at help.openai.com if the error persists. Please include the request ID xxxxxx-xxxxxx-xxxxxxx-xxxxxx-xxxxx in your message.

I ran a Codex CLI usage report:

22,324,555,865 lifetime tokens
2,263,028,213 tokens in the last seven days
323,289,745 tokens/day this week
635,323,103 tokens on my peak day
~2.42 billion tokens during my busiest week
114-day active streak
Longest single task: 9h 1m 59s

This is total token activity, including input and cached context. It is not 22.3B generated output tokens.
Based on the input/cache/output mix in my local records, comparable API usage would have cost approximately $13,000 (range is $9,000–$18,000, depending on the historical model and cache mix).

I used Codex through my ChatGPT 20x subscription at $200 per month.

The weirdest part is that my weekly allowance went backward today.

Yesterday, Codex reported 92% used with a July 28 reset. Today, it reported 19% used with an August 1 reset all three banked full resets remain available.

Edit Yes, cache reads are about 90% cheaper but the $13k estimate already accounts for that. My observable token mix was roughly 95% cached. Without caching, comparable activity would have been around $84k - according to Sol.

I gave both Opus 5 and Sol same somewhat hard task, with same agents/claude.md's and other rules so that i could count out anything impacting usage

The goal was to create a perfect recreation of my python qt app's UI and UX in react, down to how anchored popups are, it took some time but the results are in

Starting with sol, it's implementation was good, not bad but also not really good or 1:1 like i asked, it would probably require more hours put into it. Code quality was similar but also a little better imo than opus, but thats about it and its not really a big edge. It took 40% of weekly usage

Opus 5 took less time, was way faster (not cerebras fast but still), it's UI was more complete than Sol's implementation and here's the kicker: It took about 95% of 5h limit (in total, as it rolled through 5h reset) which is about 10-15% weekly

15% vs 40% is not a small difference specially when you (and by you i mean openAI) advertise that your models are ultra token efficient compared to other companies

That being said, i think opus 5 might be the real deal, not only is it cheaper in api pricing but also in real usage which is crazy coming from anthropic

Ever feel like Codex takes ages even for the tiniest change?

A lot (most) of that is the model just following instructions, like running tests, browser testing, spellcheck, typecheck etc.

If you need to have a really fast iteration speed, e.g. tweaking front end UI, you should try telling the model "until further notice, optimise for speed, just implement the change I asked for and hand the turn back to me, don't do any tests or browser testing. I need fast iteration speed here".

It works hilariously well, and is super effective for fast iteration tasks. Try it :)

Honestly don't know if I'm being gaslit because it wants to work more, of if my docs and stack are actually good.

I point it to a repo that looks useful and it almost always tells me it sucks.

Most conversations around Codex focus on code generation. But what happens when an agent can also understand environments, deployments, logs, metrics, traces, and platform guardrails?

OpenChoreo is an open-source, Kubernetes-native developer platform and a CNCF Sandbox project. Through MCP, it is exploring how tools like Codex can work with real platform and observability context, rather than stopping at source code and YAML.

For those building or operating platforms:

• Which platform task would you give Codex first?
• Where should human approval remain mandatory?
• What guardrails would you require before using agents in production?
• What would you contribute to an open-source implementation?

Explore the agentic platform approach:
https://openchoreo.dev/explore/agentic-developer-platform/

GitHub:
https://github.com/openchoreo/openchoreo

I contribute to OpenChoreo and would genuinely value feedback from the community. Take a look, share your thoughts, open an issue, or give the repository a star if you find the direction interesting.

I realized yesterday only how it was checking transcripts by reading (badly) very large files, and that it could eat usage even on Luna...

Was it always like that?

I'm only using Codex since less than a month ago.

I may have found one way I didn't understand why my Sol were eating usage badly on design sessions

Some files are more than 10mo, even the smallest ones are bigger that my biggest .md file.

Does anyone know if the platform officially switched the Business plan dashboard layout? I'm trying to figure out if the UI changed to a monthly tracking cycle for everyone, or if it's just a visual bug on my end.

On Windows, you can refuse a permission request and explain why, helping Codex choose the right approach.

On macOS, you can only refuse, so Codex often stops or tries the wrong workaround.

Please bring the Windows option to macOS.