# Feature Proposal: Adaptive SubTask Control for Codex

[Duolysis24]

Feature Proposal: Adaptive SubTask Control for Codex

I would like to suggest a more intuitive task-control system for Codex that helps users manage model selection, reasoning effort, usage, and long-running tasks more efficiently.

Problem

For complex coding or research tasks, Codex often needs different levels of reasoning for different parts of the work. Some subtasks are simple, such as inspecting files or running tests. Other subtasks need stronger reasoning, such as debugging, architecture decisions, or heavy implementation.

Right now, the user has to manually choose the model and effort level before the task starts. This can be inefficient because a single complex request may contain both simple and difficult subtasks.

Another issue is that Codex can sometimes spend too much usage on a lower-priority part of the task, or continue in a direction that the user can tell is no longer useful. When that happens, the user may need to stop the task and restart with more instructions, which wastes time and usage.

Proposal

Codex should provide one connected system for adaptive task control. This system would combine:

1. Automatic model and effort selection per subtask
2. Pre-run usage estimates
3. User-adjustable budgets for each planned subtask
4. Interruptible execution with resumable checkpoints

1. Smart Task Plan Before Starting

When a user submits a complex request, Codex could break it into subtasks before execution and show a simple plan.

Example:

| Planned subtask | Recommended setup | Estimated usage | Budget |
| Inspect the codebase | Light model, low effort | 500-1,000 | 1,000 |
| Research possible solutions | Research model, high effort | 1,500-2,500 | 2,500 |
| Implement the feature | Coding model, extra-high effort | 3,000-5,000 | 5,000 |
| Run tests and verify | Light model, medium effort | 500-1,500 | 1,500 |

Codex would recommend the best model and reasoning effort for each subtask automatically. The user could approve the plan immediately or adjust the model, effort level, or budget for any subtask.

This would reduce the need for users to constantly switch models manually.

2. Live Progress and Usage During Execution

While Codex is working, it could show a live task-control panel with:

• The active subtask
• The model and reasoning effort currently being used
• Usage so far compared with the approved subtask budget
• A short description of what Codex is currently doing
• Controls to pause, redirect, skip, change budget, or stop

If a subtask is close to its budget, Codex should pause and ask what the user wants to do.

Example:

Research is approaching its 2,500-token budget. I found two possible solutions but need more investigation. Would you like to continue, add budget, reduce effort, or move on?

If the user sets a hard limit, Codex should not exceed it without permission.

3. Interrupt and Redirect

Users should be able to interrupt a running subtask when Codex starts drifting, repeating itself, hallucinating, or focusing on something unimportant.

Example:

• Task A uses 1,000 tokens and is completed.
• Task B uses 2,000 tokens and is completed.
• Task C has a 4,000-token budget.
• After using 1,000 tokens on Task C, Codex starts going in the wrong direction.
• The user pauses Task C and gives a correction.
• Tasks A and B stay completed.
• The remaining 3,000-token budget for Task C can be reused for the corrected approach.

This would make long tasks much easier to steer without needing to restart the whole prompt.

4. Resumable Checkpoints

Codex could automatically create a checkpoint after each completed subtask and whenever the user pauses execution.

A checkpoint should save:

• Completed work
• Important findings and decisions
• Files created or changed
• Sources already reviewed
• Remaining subtasks and budgets
• A short summary of the abandoned or interrupted approach

The user could then resume from the latest checkpoint, redirect the current subtask, or return to an earlier checkpoint without needing Codex to reconstruct everything from the beginning.

Why This Matters

These features should work together as one intuitive experience, not as separate advanced settings.

The ideal workflow would be:

1. Codex breaks the request into subtasks.
2. Codex recommends the best model and effort level for each subtask.
3. The user sees an estimated usage range before approving the plan.
4. Each subtask has an adjustable soft or hard budget.
5. The user can pause, redirect, skip, or continue during execution.
6. Codex saves checkpoints so completed work does not need to be repeated.

This would make Codex more efficient, predictable, and controllable for long coding, debugging, research, and multi-stage implementation tasks.

The main goal is not just to show token usage. The goal is to give users meaningful control over how Codex spends reasoning effort and usage across a complex task.