Feature Request: Quota-Aware Adaptive Auto Mode with User-Defined Model Bounds

ChatGPT Feature requests
, , ,
1

I want to request an adaptive Auto mode for model and reasoning selection that intelligently uses the models and quotas available to the user.

The core idea is simple:

ChatGPT should automatically use whichever available model or combination of models is most appropriate for the task, while making efficient use of the user’s remaining quotas.

Users should not have to predict in advance how much reasoning a request will require. The system is in a much better position to determine that while solving the task.

One Auto mode, not several optimization presets

I prefer one Auto mode rather than separate “Economy”, “Balanced”, or “Quality” modes.

The objective of Auto should already be to make the best possible use of the resources available to the user:

maximize solution quality within the user’s available computational and quota constraints.

This should not simply mean “use the cheapest model possible”. If a stronger model would materially improve the result, Auto should be able to use it. If a simpler part of the task does not require it, the system should conserve the more limited quota.

Auto could therefore dynamically:

  • select the appropriate model and reasoning effort;
  • escalate when a task turns out to be more difficult than expected;
  • reduce reasoning effort or use a less expensive model when appropriate;
  • take remaining daily or weekly quotas and their reset times into account;
  • potentially use different models for different parts of the same request while preserving context.

User-defined minimum and maximum

Automatic selection should not mean giving up control over quality.

I would therefore like users to be able to define an optional minimum and maximum model/capability level within which Auto is allowed to operate.

For example:

Minimum: GPT-5.6 Sol
Maximum: GPT-6 Astra

Auto could freely optimize within that range, but it would never drop below the user’s chosen minimum or exceed the chosen maximum.

This would be particularly useful for users who want automation but do not want quota efficiency to reduce quality below a personal minimum standard.

Optional approval for model changes

The same Auto system could support two control styles:

Automatic changes — ChatGPT may switch models or reasoning levels autonomously within the configured bounds.

Ask for approval — ChatGPT briefly asks before changing model/capability level.

For example:

“This part of the task would likely benefit from a higher-capability model and would consume limited Pro quota. Switch?”

Approval should be available for both upward and downward changes. Some users may care more about preventing an unnecessary downgrade than preventing use of a premium model.

Transparency

Even in fully automatic mode, the process should remain inspectable.

After or during a response, users should be able to see:

  • which model or models were used;
  • which reasoning levels were used;
  • whether multiple models contributed to one request;
  • which limited quota was consumed.

For example:

Models used: GPT-5.6 Sol → GPT-6 Astra → GPT-5.6 Sol

This would provide transparency without requiring the user to micromanage every routing decision.

Manual mode should remain

Manual model and reasoning selection should remain available for power users who explicitly want full control.

The intended structure would therefore be simple:

Auto — adaptive resource allocation within optional user-defined bounds
Manual — explicit user selection

The goal is to let users focus on the problem they want solved, while still giving them clear boundaries and transparency over how ChatGPT uses their available resources.

2

I strongly support this proposal. I am experiencing exactly the problem this feature is trying to solve, and I would like to suggest one important extension: adaptive escalation and de-escalation based on actual problem-solving performance, not only on predicted task complexity or remaining quota.

In my experience, the most frustrating situation is not necessarily the lack of access to a powerful model. It is having to manually manage the models during a difficult task.

For example, I may start working with a lower-cost model such as Luna. If it cannot solve a programming problem after several attempts, I have to manually switch to a stronger model. Sometimes the stronger model solves it immediately; sometimes I have to switch again. Once the problem is solved, I would ideally want ChatGPT to automatically return to the lower-cost model.

I propose an Adaptive Escalation Loop:

Luna → Terra → SOL → Astra

  1. Start with the least expensive model.

  2. Let it attempt the task.

  3. If it is making meaningful progress, keep using it.

  4. If it repeatedly fails, contradicts itself, repeats the same unsuccessful approach, or fails verification/testing, automatically escalate to the next model.

  5. Continue escalating only when necessary.

  6. Once the difficult problem is solved, automatically de-escalate to the least powerful model capable of handling the next task.

For programming, verification could make this especially effective:

generate solution → test/verify → failure → another attempt → repeated failure → escalate.

The most important requirement is persistent context.

Switching models should never mean starting a new conversation. Every model should receive the same conversation state: previous messages, code, files, errors, failed attempts, successful solutions, user instructions, and decisions.

For example:

Luna → Terra → SOL → Astra → SOL → Luna

The user should experience this as one continuous conversation, not as manually switching between separate models.

I also believe the system should optimize for total user productivity, not simply model quota. A lower-cost model that requires 15 additional iterations can consume far more of the user’s time than a stronger model that solves the problem in one or two attempts.

This would make Adaptive Auto much more powerful:

Use the cheapest model that can successfully solve the current problem, automatically escalate when it cannot, and automatically return to the cheaper model once the difficult part is solved — while preserving the complete conversation context.

I believe this could benefit both users and OpenAI by reserving the most expensive reasoning capacity for the problems that genuinely require it, rather than using it continuously or forcing users to manually manage model selection.

3

I strongly support keeping manual model selection available.

My concern is not only about performance or quotas. I would specifically like GPT-5.6 Sol to remain available as a legacy option after GPT-6 Astra becomes the default.

For users who have long-running conversations with ChatGPT, different models can feel meaningfully different in their tone, humor, timing, and conversational style. A newer or more capable model is not necessarily a direct replacement for the experience of using a model we have become accustomed to.

I am interested in using GPT-6 Astra too. I simply do not want the transition to be forced. Please allow users to choose whether and when to move to a newer model, and to return to GPT-5.6 Sol when they prefer it.

For conversational users, model continuity is part of the product experience, not just model capability.