[Feature Request] Per-thread Auto mode that routes both model and reasoning effort

What variant of Codex are you using?

Codex Desktop on macOS. The same capability would also be useful in the CLI and IDE extension.

What feature would you like to see?

Summary

Add a per-thread Auto mode that chooses both the model and reasoning effort before each turn.

With GPT-5.6 Sol, I built a local macOS prototype called Codex Auto to explore this workflow. The user selects 1–5 permitted models and the allowed effort tiers for each model. Before a turn starts, the router makes two separate decisions:

• Model: based on judgment difficulty, ambiguity, risk, and prior failures.
• Reasoning effort: based on execution scope, verification burden, depth, and parallel work.

The selected model and effort should be visible in Codex's native selector, with a short reason. Manual selection must always win.

Why this is needed

Real Codex work is not uniformly difficult. A single thread can move between:

• mechanical edits, searches, formatting, and running known commands;
• normal multi-file implementation;
• unknown-root-cause debugging, architecture, migration, privacy, or security decisions.

A fixed model/effort combination creates two expensive failure modes:

1. Over-allocation: a frontier model at high effort spends unnecessary tokens and latency on simple work.
2. Under-allocation: a weaker model or low effort misses hidden complexity, causing retries, larger patches, more review, and more total token usage.

The useful metric is not the price of one turn. It is total task-completion cost: tokens + latency + retries + review + risk. An Auto mode should downshift routine work and upshift when uncertainty or consequences justify it.

This should materially reduce wasted tokens in suitable workloads, but the product should measure it with controlled evaluations instead of advertising an unverified savings percentage.

Proposed UX and safeguards

• Per-thread Auto toggle, off by default.
• User-selected pool of 1–5 models; Auto never escapes that pool.
• Per-model allowlist/min/max for reasoning effort; Ultra requires explicit opt-in.
• Quality, balanced, and speed policies.
• Model and effort are routed independently.
• Native selector always displays the effective model and effort.
• A short, inspectable reason is shown for the current turn.
• Manual override/pin is authoritative.
• Hysteresis prevents rapid oscillation, but cannot override a risk floor.
• No automatic rerun after tool side effects.
• If the route cannot be applied atomically, keep the draft and attachments intact and do not silently send with the wrong settings.
• Raw prompts, assistant text, attachments, and full paths are not required for persistent routing telemetry.

Prototype evidence and the important failure

The prototype currently has 334 passing automated tests:

• 287 XCTest tests
• 23 Swift Testing tests
• 24 pytest/Hypothesis tests

They cover per-thread isolation, 1–5 candidate boundaries, per-model effort allowlists, manual override, fallback, privacy, native-selector readback, transcript verification, and single-admission safeguards.

The real Desktop test revealed the most important product boundary: a third-party extension does not currently have a supported, atomic pre-submit primitive for updating both model and effort. A transparent app-server shim could change the visible model, but real Desktop submissions then produced Error submitting message. I removed the shim and restored the official app-server path instead of presenting the prototype as production-ready.

That result is why this capability belongs in Codex itself rather than in a fragile third-party proxy.

Product primitive that would unblock this

A supported host-level operation, conceptually:

set_next_turn_route(thread_id, model, reasoning_effort, reason, policy_revision)

It should:

1. validate the model/effort combination against the live catalog;
2. apply the route before the user message becomes a turn;
3. update the native selector;
4. preserve the original message and attachments;
5. create exactly one user message and one turn;
6. expose the actual model/effort in the turn/transcript truth;
7. return a clear failure without starting the turn when the route cannot be applied.

Codex itself could then supply the built-in policy, while an optional extension API could allow local/custom policies within user-defined caps.

Acceptance criteria

• Auto can select different models and effort tiers on different turns in the same thread.
• New threads remain native/off unless the user enables Auto.
• The native selector and transcript agree with the effective route.
• One submit produces one user message and one turn, including with attachments.
• Manual overrides always win.
• Routing failures never silently use an unintended model/effort.
• Evaluation reports total completion cost and quality, not only per-turn token use.

Related

• #8649 — harness-driven Auto reasoning effort.
• #20855 — model-callable reasoning “gearbox”.
• #26996 — different model/speed choices for planning and implementation.

This proposal extends the same direction to joint model + effort routing, with per-thread user control and native Desktop synchronization.