Feature request: Manager Mode — autonomous, cost-aware orchestration for non-technical users

What variant of Codex are you using?

App / Work (product-level proposal that could also apply to Codex generally)

What feature would you like to see?

I would like to propose a first-class Manager Mode for Codex / ChatGPT Work.

The core idea is simple:

Do not make the customer design the company. Give the customer the company, and let them talk to the manager.

I am a non-computer-science student. From my perspective, the current agent stack is already technically powerful: models, reasoning levels, subagents, tools, skills, long-running tasks, parallel work, Work, Codex, etc. The remaining barrier is that ordinary users are still expected to think like an engineer when deciding how to combine them.

Today, for a complex project, a user may still need to decide:

• whether to use ChatGPT, Work, or Codex;
• whether the task should be split into subagents;
• which subtasks can run in parallel;
• which model and reasoning level should handle each phase;
• how much context each worker should receive;
• when to escalate a failed task to a stronger model;
• when a cheap model is good enough;
• how to avoid duplicated context and unnecessary token consumption;
• which decisions really require the user.

For technical users, these are manageable configuration choices. For non-technical users, they are effectively an orchestration problem that should be solved by the AI itself.

Proposed experience

The user should be able to say something like:

“Translate this scanned PDF book into Chinese. Preserve the layout and images, keep terminology consistent, produce a Word file and a bilingual PDF, prioritize quality but avoid wasting compute. Ask me only when there is a genuine editorial decision.”

Manager Mode would then autonomously:

1. understand the overall goal and success criteria;
2. inspect the input modality and project state;
3. decide whether multiple workers/subagents are useful at all;
4. create only the necessary workers;
5. assign each worker the most appropriate model and reasoning effort;
6. run independent subtasks in parallel where useful;
7. give each worker only the minimum context it needs;
8. route routine work to cheaper/faster models and difficult work to stronger models;
9. use tools or deterministic processing when an LLM is unnecessary;
10. detect low-confidence or failed work and selectively escalate it;
11. maintain one canonical project state, terminology set, decisions, files, and checkpoints;
12. validate intermediate and final results;
13. expose cost / quota impact and avoid unnecessary fan-out;
14. interrupt the user only for real decisions, permissions, or ambiguity that cannot be resolved safely;
15. deliver the final artifact, not merely a plan.

The important UX change is that the user interacts primarily with one manager, not with the underlying worker architecture.

A user-facing view could be as simple as:

Project: Translate Book
Progress: 68%

OCR / document extraction: complete
Translation: 17 / 24 chapters
Review: 11 / 24 chapters
Automatically resolved issues: 137

Needs your decision: 2

The detailed task tree, models, reasoning levels, worker logs, and token usage could remain inspectable for advanced users, but they should not be prerequisites for getting work done.

Why cost-aware orchestration matters

Multi-agent systems can easily become less efficient if every worker repeatedly receives the full context or if multiple expensive models re-read and rewrite the same material.

A good Manager Mode should optimize the net value of delegation, not maximize the number of agents.

For example, instead of:

strong model reads whole book
→ another strong model reads whole book
→ another strong model reviews whole book
→ final strong model reads everything again

it should prefer something like:

deterministic extraction where possible
→ cheap worker handles routine pages
→ strong multimodal worker only sees uncertain pages
→ translation workers receive bounded chapter context + glossary
→ reviewer sees only flagged sections / consistency reports
→ strong model performs final high-risk review

This would improve both quality and effective quota / inference cost.

A mature manager should follow a principle such as:

Use the least expensive model that can reliably complete the task, and escalate only when evidence justifies it.

It should also avoid unnecessary “AI meetings”: workers should exchange compact task contracts, files, state, and exception reports rather than repeatedly restating full histories.

Why this could be a separate product mode

I think this is meaningfully different from ordinary Chat and from Codex as a coding-focused execution environment.

A possible product progression is:

Chat AI      → answers questions
Work AI      → executes substantial tasks
Manager AI   → organizes multiple models / agents / tools to deliver a project

Manager Mode could therefore be a first-class mode alongside Chat / Work / Codex rather than requiring users to manually assemble orchestration through configuration files, prompts, or developer tooling.

The target audience would include students, researchers, teachers, writers, analysts, small-business users, and other people who can define goals and judge outcomes but do not want to learn agent infrastructure.

Human role

The goal is not to remove human control. It is to move the human to the right level of abstraction.

The human should decide:

• goals;
• quality standards;
• budget / compute limits;
• subjective choices;
• sensitive permissions;
• whether to accept the final result.

The manager should decide routine technical implementation details whenever it can do so safely and transparently.

Additional information

I searched the existing Codex issues first. Several requests appear to cover important pieces of this proposal:

• #34388 — Smart Mode for automatic model and reasoning-effort selection
• #33249 — ChatGPT supervising active Codex tasks
• #37736 — “My AI Team” with persistent specialists
• #40037 — dynamic multi-agent graphs and evidence-driven escalation

I see this proposal as a higher-level product/UX layer that connects those capabilities for ordinary users, rather than a replacement for any one of them.

The individual technical primitives increasingly exist. The missing layer is an AI manager that makes the primitives disappear behind a natural-language interface.

This proposal was developed through a conversation with ChatGPT and then reviewed and approved by me. I am intentionally not including personal identifying information beyond the fact that I am a non-computer-science student.

The issue names no files, tests, or entry points and proposes a broad product and UX layer rather than a scoped repository change. Start by reviewing related issues #34388, #33249, #37736, and #40037; a concrete implementation target and completion criteria are needed before coding can begin.