Repository navigation
Description
What variant of Codex are you using?
Codex CLI
What feature would you like to see?
I would like Codex to introduce an intelligent, cost-aware model routing system combined with automatic failure detection, project protection, and credit efficiency controls.
As a paying user, I have experienced a noticeable decline in Codex reliability and efficiency over the past 2–4 months. Tasks that previously worked reliably now frequently require repeated attempts, extensive explanations, and additional credits to repair unintended changes.
Requested features:
1. Intelligent automatic model selection
- Automatically select the most cost-effective model for each task.
- Use lightweight models for straightforward coding and file operations.
- Use more capable models for visual website development, complex reasoning, and architectural changes.
- Automatically escalate when a weaker model struggles.
- Switch models during execution when necessary.
- Allow users to configure model limits and credit budgets.
2. Automatic failure detection
Codex should recognize when it is repeatedly failing, misunderstanding instructions, or producing incorrect results.
Instead of continuing to modify code and consuming credits, it should stop, reassess, switch models, or request approval.
3. Protection against destructive changes
Before modifying existing projects, Codex should create recoverable checkpoints.
It should verify that previously functioning components continue working after modifications.
If a change breaks existing functionality, Codex should automatically revert the change or stop for user approval instead of introducing further problems.
4. Intelligent credit management
- Detect repetitive or unproductive operations.
- Warn users when credits are being consumed without meaningful progress.
- Show which models are being used and why.
- Allow automatic stopping when repeated attempts fail.
- Prioritize successful results per credit rather than simply minimizing the cost of individual model calls.
5. Improved long-term project consistency
Codex should preserve architectural decisions, working functionality, and project context across long development sessions.
It should not unnecessarily rewrite working code or lose track of previously completed work.
The primary goal is simple: Codex should know when to use a stronger model, when a cheaper model is sufficient, and most importantly, when to stop before causing damage.
Related issue: #43868 (Smart Model Picker).
This request expands on that proposal by including failure detection, automatic recovery, project safety, and credit efficiency.
Additional information
I want to share my personal experience to explain why these improvements matter.
I have been a paying ChatGPT user for a long time and previously had an excellent experience using ChatGPT and Codex together.
I successfully developed major creative projects, including my book "The Flying Crown", using these tools. At that time, the coordination, understanding, and reliability were outstanding.
However, over the past 2–4 months, my experience has changed significantly.
Codex now frequently struggles with tasks it previously handled successfully. It sometimes damages working website components, continues attempting unsuccessful solutions, and consumes additional credits fixing problems caused by its own modifications.
I have increasingly resorted to using the strongest available model because I cannot trust weaker models to recognize their limitations and stop before making destructive changes.
Another major problem: Overconfidence and failure to clarify instructions
One of my biggest frustrations is that Codex frequently assumes it understands exactly what the user means without verifying that understanding.
Both ChatGPT and Codex sometimes respond with statements such as "I know exactly what you mean" or "I understand precisely what you want", expressing an almost arrogant level of confidence.
However, the AI often demonstrates shortly afterward that it did not understand the request at all.
Instead of asking a simple clarification question when an instruction is genuinely ambiguous, Codex immediately starts modifying files, writing code, or making architectural decisions based on incorrect assumptions.
This results in wasted credits, unnecessary changes, and sometimes damage to existing functionality.
What makes this especially frustrating is that the AI sounds completely certain about its interpretation, even when that interpretation is wrong.
I would like Codex to introduce better uncertainty awareness and clarification behavior:
- Recognize when instructions are ambiguous or when important details are missing.
- Ask targeted clarification questions before starting potentially expensive or destructive work.
- Avoid claiming complete understanding unless the task requirements are sufficiently clear.
- Distinguish between what the user explicitly requested and what the AI is merely assuming.
- Present critical assumptions for approval before making major changes.
- Prefer asking one short question over wasting significant credits executing an incorrectly understood task.
- Recognize when its initial interpretation was wrong instead of confidently continuing down the same path.
An AI assistant should not behave as though it is always right. It should recognize uncertainty and communicate it appropriately.
Comparison with Claude Code
I recently used Claude Code extensively on the same website development projects.
During one period, it worked for approximately 64 hours continuously. Over five days of active usage, I eventually reached my weekly limit without hitting the five-hour usage limit once.
I understand that the two platforms calculate usage differently. However, Claude Code consistently delivered more reliable, completed work with fewer unnecessary corrections in my experience.
Without Claude Code, my website would not be where it is today.
This is not simply a complaint about pricing.
I am concerned about declining reliability, unnecessary credit consumption, excessive confidence despite misunderstanding instructions, and the lack of safeguards when AI agents make mistakes.
When an AI introduces errors into previously functioning code, users should not repeatedly lose additional credits simply because the agent continues making unsuccessful attempts.
Likewise, users should not lose credits because Codex confidently starts working on an interpretation it never verified.
I have even postponed a planned sequel to "The Flying Crown" because I no longer have the same confidence in the tools that previously helped me complete the original project.
I genuinely want Codex to improve. I would prefer to continue using OpenAI's tools, but I need an agent that recognizes its limitations, asks questions when necessary, protects existing work, manages resources intelligently, and delivers consistent results.
Please consider these improvements as an integrated system rather than separate features.
Reliability, honest uncertainty, clarification before execution, intelligent model selection, and credit efficiency should work together.
The goal should not be to make an AI sound more confident. The goal should be to make it more accurate, trustworthy, and capable of recognizing when it does not yet understand the user's intentions.
Activity
github-actions commentedon Nov 21, 2026
Potential duplicates detected. Please review them and close your issue if it is a duplicate.
Powered by Codex Action
marvelett-wq commentedon Nov 21, 2026
Thank you for identifying #62394 as a potential duplicate.
I have reviewed the proposal and agree that there is some overlap, particularly regarding automatic model selection, task-aware execution, and resource optimization.
However, my request addresses additional problems that I believe deserve specific attention.
My main concern is not simply how Codex selects models or coordinates agents. It is how Codex behaves when it misunderstands a user's intentions or lacks the capability to complete a task reliably.
In my experience, Codex frequently expresses complete confidence that it understands a request, then immediately begins making changes based on incorrect assumptions.
This consumes credits before the misunderstanding is discovered and can damage previously functioning code. Users then spend additional credits repairing those mistakes.
I am specifically requesting:
I also reviewed #61876, which addresses resource optimization and unsuccessful execution loops. While relevant, neither proposal fully addresses the combination of premature execution, overconfidence, destructive modifications, and the resulting cost to users.
I believe these proposals are complementary rather than complete duplicates.
I would therefore prefer to keep #62942 open as a separate feature request, unless the maintainers determine that these specific concerns are already fully covered.
Thank you for considering this distinction.