I would like to suggest an automatic multi-model routing mode for Codex, where Codex dynamically chooses between Sol, Terra and Luna for different parts of the same task instead of running the entire workflow on one model.
The idea would be for Sol to act as the lead architect / supervising agent, while cheaper models perform work that does not require frontier-level reasoning.
For example:
- Sol — understand the overall objective, design the approach, make architecture decisions, handle difficult debugging, review important changes and supervise the task.
- Terra — perform most normal implementation work, refactoring, testing and moderately complex coding tasks.
- Luna — handle high-volume and lower-complexity work such as reading/searching files, repository discovery, simple configuration changes, repetitive edits, log analysis, boilerplate and straightforward documentation updates.
Codex should be able to escalate work automatically if a lower-tier model becomes stuck or determines that a task requires stronger reasoning.
Example workflow
A user could simply ask:
“Implement this feature, update the tests and documentation, and make sure everything passes.”
Codex might internally perform something like:
- Sol analyses the requirement and creates the implementation plan.
- Luna scans the repository and identifies relevant files.
- Terra implements the main code changes.
- Luna updates straightforward tests/configuration/documentation.
- Terra investigates any test failures.
- Sol reviews the final implementation, architecture and risks before completion.
This would allow users to focus on the objective rather than manually choosing which model should perform each individual step.
Why this would be useful
The biggest benefit would be significantly better compute and usage efficiency.
Many Codex tasks contain a mixture of difficult reasoning and very simple operations. Using a frontier model for every file read, search, small edit or repetitive operation consumes premium model allowance unnecessarily.
Automatic routing could therefore:
- Reduce Sol usage significantly.
- Make Plus and other subscription allowances last much longer.
- Allow longer autonomous Codex sessions.
- Reduce the cost of large agentic development workflows.
- Improve task completion by allowing Sol to concentrate on the areas where its reasoning capability provides the most value.
- Potentially reduce inference costs for OpenAI as well.
Suggested user modes
It could also be useful to expose different routing profiles:
- Economy — primarily Luna/Terra, escalating to Sol only when necessary.
- Balanced — Sol supervises while Terra/Luna perform most implementation work.
- Maximum Quality — uses Sol more extensively where quality is prioritised over usage efficiency.
Transparency
It would also be useful if Codex showed model routing in the activity feed, for example:
- Sol — Planning architecture
- Luna — Scanning repository
- Terra — Implementing backend changes
- Luna — Updating tests
- Terra — Resolving test failures
- Sol — Reviewing final implementation
This would give users visibility into where their premium model allowance is being consumed.
Overall, I think automatic hierarchical model orchestration could make Codex considerably more powerful and economical, particularly as tasks become longer-running and increasingly autonomous.
Rather than requiring users to decide which model should handle an entire task, Codex itself could optimise for:
Highest probability of successfully completing the objective while using the minimum amount of premium compute necessary.
)