Codex Orchestration: assign Planner, Advisor, Designer and Executor roles inside Codex
Bring any model to Codex, assign them any role, use them in /goal or any workflow.
At a glance
- What is it?
- Codex Orchestration is a Codex plugin that routes planning, review, design and implementation to different models, with the current Codex model still coordinating and delivering. The interesting part is the approval loop; the sharp edge is that Planner and Advisor must be separate routes.
- Who is it for?
- Adopt Codex Orchestration if you already run Codex tasks and want plan review before code changes, and you have at least two distinct model routes available. Skip it if you only have one model, or if you need a design handoff but cannot supply a separate Designer route.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 11 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 8, 2026, and from our analysis. They are not legal advice.
Editorial analysis
The problem Codex Orchestration solves, and who it is for
A single Codex model does planning, review and implementation in one pass. The README frames the plugin as a way to separate those jobs: bring Fable 5, Opus 5 or another compatible model into Codex, give each one a role, and let Codex coordinate the work. The target reader is someone already working inside Codex who wants a plan checked before code changes begin, not someone looking for a standalone agent framework.
The four roles are explicit. Planner creates the plan and improves it after feedback, and it is optional; when omitted, the current Codex model plans. Advisor reviews the plan, finds gaps and approves it. Designer turns approved requirements into a bounded visual, UX, interaction, information-architecture or design-system handoff, also optional. Executor implements the approved plan and is the only required role.
The README is direct about who stays in charge: the model selected for the Codex task remains in charge, passes work between the roles, checks every result and gives the final answer. That is a coordination model, not a handoff model. If you want a system where a sub-agent owns the task end to end, this is not it.
How the Planner, Advisor and Executor loop actually runs
The README includes an ASCII flow. Your task goes to Codex, which coordinates. The Planner produces a first plan. The Advisor reviews it and either finds real gaps or approves. If it needs work, the Planner improves it and the loop repeats. Codex stops as soon as the Advisor returns PLAN_APPROVED, with a safety limit of eight reviews. If approval is not reached, execution stops and Codex shows you the latest plan and unresolved issues.
That eight-review ceiling is the most concrete design decision described. It bounds the cost of a disagreement between two models that will not converge. The failure mode is equally concrete: you get no execution, just a plan and a list of unresolved issues. Whether that is better than a mediocre plan is a judgement call, and the README does not offer a fallback path.
The Designer sits after approval and before execution. It is described as an optional design handoff, and the README does not document rollback if the Designer's output is rejected. The Executor then implements, and Codex tests and delivers. The README also states that independent implementation work can run in parallel, with a stated target of up to 2x faster on suitable tasks, and that moving repeatable work away from the root model may hit premium-model limits about 40% less often. Both figures are labelled as targets, not guarantees, and they depend on the models, task, context, retries and available parallel work.
Installing the Codex Orchestration plugin
Installation is two Codex plugin commands. The README says setup requires Python 3.11 or newer, and that you should start a new Codex task after installation.
codex plugin marketplace add Cjbuilds/Codex-Orchestration
codex plugin add codex-orchestration@codex-orchestrationThe first command registers the marketplace, the second installs the plugin itself. After that, start a new Codex task so the plugin is picked up.
The first real use is a prompt, not a terminal command. You start an ordinary Codex prompt with the literal skill label $codex-orchestration:codex-orchestration, then supply roles. This example uses Fable 5 to plan, Sol to advise and Luna to implement:
$codex-orchestration:codex-orchestration setup planner: Claude Fable 5 High, advisor: GPT-5.6 Sol High, executor: GPT-5.6 Luna Extra HighWhen every requested route is ready in the current task, the plugin confirms only the roles you supplied, in your order, with lines such as "Planner: Fable 5 high: Activated". The README is careful about that word: Activated means the route is ready and callable for that task. If an external model still needs authentication, qualification, connection or a restart, the plugin reports that exact state and next action instead of claiming activation.
After setup, start another new task and use Codex normally. The README states the saved workflow applies automatically. You can also browse installed skills with Codex's built-in /skills discovery.
Effort levels, Claude Code requirements and the no-API-key path
Fable 5 defaults to High and accepts Low, Medium, High, XHigh or Max. Ultra is accepted as an alias for Max because Claude Code does not expose a separate Ultra effort. Opus 5 also defaults to High and supports the same five exact effort values, but not the Fable-only Ultra alias. Opus requires Claude Code 2.1.219 or newer, which is the one hard version floor in the README besides Python 3.11.
The authentication detail matters if you assumed an API key was needed. Fable 5 and Opus 5 use the official Claude Code CLI and a compatible first-party Claude login. The README states you do not need to add an Anthropic API key to Codex. That keeps credential handling inside Claude Code, but it also means the plugin inherits Claude Code's login state and its version constraints.
Role labels are literal, and the README is emphatic about it: a model after planner: plans, a model after advisor: reviews, a model after designer: designs, a model after executor: implements. It adds that Codex must never move a model to a different role because that model was used differently in an older plugin version. If you omit Designer, the workflow has no Designer. If you specify Planner and Executor but omit Advisor, the workflow has no Advisor. Nothing is silently filled in.
The independence rule is the constraint that decides most setups
Planner and Advisor must use different configured model routes so the review is independent. That single sentence rules out the simplest configuration people will try: one model doing both jobs. If you have access to only one external model, you can still run the plugin, but you either drop the Advisor (and lose plan review entirely) or let the current Codex model plan while the external model advises.
The README gives that second pattern as a supported example: let your current Codex model plan and use Fable 5 only as Advisor. It also shows Opus 5 as Advisor with GPT-5.6 Luna Extra High as Executor. So the minimum useful setup is one external route plus Codex, not two external routes.
The natural-language status check is a smaller but useful mechanism. You can ask "is Kimi available to use as Designer?" without selecting the skill first. The README states the plugin checks its External Model registry instead of guessing from the visible tool list, and that it distinguishes whether a model is bundled and supported, configured on this installation, and callable in the current task. A question performs read-only status inspection only; it never authorizes configuration, credentials or spend. That last clause is a deliberate boundary, and it is the kind of thing worth reading twice before wiring the plugin into an automated flow.
Where Codex Orchestration is the wrong tool
The eight-review limit is a real ceiling, not a soft one. If your Planner and Advisor disagree on a task where the requirements are genuinely ambiguous, you get a stopped run and a list of unresolved issues rather than an implementation. There is no documented override in the README, no flag to raise the limit, and no documented way to force execution past a failed approval. For exploratory work where a rough plan is fine, the review loop is overhead you are paying for.
The design handoff is bounded by the README's own wording: a visual, UX, interaction, information-architecture or design-system handoff. It is not a general-purpose second opinion stage. If you need a model to critique architecture decisions rather than shape a user-facing experience, the Designer role is the wrong slot, and the Advisor slot is occupied by plan review.
There is also a version dependency that is easy to miss. Opus 5 requires Claude Code 2.1.219 or newer, and the README does not document what happens on older versions beyond the requirement. If your environment pins Claude Code, check that floor before planning a rollout. Finally, the parallel-execution and premium-limit figures are stated as targets. The README explicitly says results depend on the models, task, context, retries and available parallel work, so treat them as direction, not as a capacity plan.
Compared with running Codex alone or a general agent framework
The alternative most readers already have is plain Codex with no plugin: one model plans, reviews its own plan and implements. The difference is structural rather than a matter of model quality. Codex Orchestration inserts an independent route between planning and execution, and the Advisor can return PLAN_APPROVED, which is a machine-readable gate. Plain Codex has no such gate; nothing stops it from moving from plan to code in the same pass.
The second alternative is a general multi-agent framework where agents own subtasks. The README draws the boundary itself: the model selected for the Codex task remains in charge, passes work between the roles, checks every result and gives you the final answer. Orchestration here is centralized coordination inside Codex, with role labels that are literal and not reassignable. A framework that lets agents negotiate or hand off ownership is a different shape, and the plugin's fixed four-role vocabulary will feel restrictive if that is what you need.
The third comparison is within the plugin: a setup with an Advisor versus one without. Omitting the Advisor is supported and documented. You keep the Planner and Executor split and lose the review gate entirely. That is a legitimate configuration for low-risk work, and the README does not discourage it.
Maintenance, licence and what a contributor inherits
The repository is not archived, and the last push was on 2026-09-01. The top-level layout includes .agents/, .githooks/, .github/, docs/, plugins/, scripts/ and tests/, plus AGENTS.md, CHANGELOG.md, CONTRIBUTING.md, RELEASE.md and SECURITY.md. That is a maintained project structure with a changelog and a release document, though no releases were retrieved for this article, so the RELEASE.md contents are not something I can describe.
requirements-dev.txt sits at the top level, which points at a development dependency set separate from the runtime requirement of Python 3.11 or newer stated in the README. The tests/ directory and the .githooks/ directory suggest the project expects contributions to run checks locally, but the README does not document a test command, and I will not invent one.
The licence is MIT. That is permissive and short, and it is the licence file at the repository root. It says nothing about the terms attached to the external models you route through the plugin. Fable 5 and Opus 5 are reached through the official Claude Code CLI and a first-party Claude login, so their own usage terms apply to those calls, and the plugin's MIT licence does not extend to them. I am not giving legal advice; read the terms of the model providers you configure.
Upgrade cost is the part the README leaves thinnest. The plugin installs through the Codex plugin marketplace, so updates flow through that channel, but the README does not document a rollback procedure, a version pinning mechanism, or what happens to a saved workflow when the plugin updates. Given that role labels are literal and the README warns against Codex reassigning a model's role based on older plugin behaviour, that gap is worth checking against CHANGELOG.md before you upgrade a working setup.
Editorial conclusion
Adopt Codex Orchestration if you already run Codex tasks and want plan review before code changes, and you have at least two distinct model routes available. Skip it if you only have one model, or if you need a design handoff but cannot supply a separate Designer route. Before trusting it, verify that the Advisor reports PLAN_APPROVED on a small task and that the eight-review safety limit is visible in your task output.
Frequently asked questions
Is Codex an orchestrator?
In this plugin, yes: the README states the model selected for the Codex task remains in charge, passes work between the Planner, Advisor, Designer and Executor roles, checks every result and gives the final answer. The external models do not take over the task.
Is codex using GPT-5?
The README does not state which model Codex itself uses. It only shows GPT-5.6 Sol, GPT-5.6 Luna and GPT-5.6 Terra as models you can assign to the Advisor, Executor and Designer roles.
Is codex an IDE like vscode?
The README does not describe Codex as an IDE. It describes Codex as the coordinator of a task, and the plugin is installed with codex plugin commands and used through prompts and the built-in /skills discovery.
Is codex made by OpenAI?
The README does not state who makes Codex. It only refers to Codex's built-in /skills discovery and to the Codex plugin marketplace used to install Codex Orchestration.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/cjbuilds-codex-orchestration)