I am using the following prompt in Codex when I use GPT 6 Astra:
Proceed to implement all the tasks in this plan in a new branch or worktree, and respect dependency requirements. Spawn subagents (in parallel, if possible) to implement each task. Use herdr when starting codex subagents.
For all subagents that are writing related, including writing parts of a paper or a plan, always use gpt-6-astra at high reasoning level. For subagents that are coding or review related, always use codex gpt-5.6-sol at xhigh reasoning level. Make sure red/green TDD is used for in all coding subagents. For each task, spawn its own fresh subagent to implement it with well-defined acceptance criteria, and then spawn another subagent to review the implementation and whether the criteria is satisfied. When a review subagent has findings that are of critical, high, or medium priority that you believe should be fixed, reuse the existing implementation subagent to fix them instead of spawning fresh ones, but use a fresh review subagent to review again. No nested subagents are allowed: subagents should not spawn their own subagents.
Iterate through this fix-review cycle until the review subagent has no more findings of critical, high, or medium priority and that do not add more features or over-engineer. If tasks are divided into phases, add a review gate, as a gpt-6-astra medium subagent, to review each phase before committing. Do not be overly strict when reviewing each task or phase, but also do not weaken tests or acceptance criteria just to obtain a passing review. Revalidate if integration changes the reviewed code. Reviewing subagents should name the exact commit they reviewed, and you (the orchestrator) should be in charge of resolving dependency conflicts across phases. Bring genuine conflicts to me rather than silently changing scope.
Do not write tests (and ask your subagents not to) for reversible, low-impact changes that mirror the implementation. If you do choose to verify your work with tests, make sure that the tests are meaningful and necessary to verify implementation.
Run tests appropriate to the change and complete required checks. Once those pass, broaden or repeat testing only when new changes, failures, or unresolved concerns justify it; otherwise, continue toward completing the task. Ask your subagents to follow this policy as well.
After completion, each phase or task should be committed with a detailed commit message, and pushed to the remote origin. A PR with a detailed description should be opened after the first phase is completed, and updated as soon as future phases are done. Do not move on to the next phase without completing existing phases. After a task is completed (reviewing subagent passed without issues above LOW), you (the orchestrator) should clean up all the temporary worktrees, /tmp directories, build artifacts, herdr workspaces, and quit all codex subagents related to the completed task. If evidence data is essential, commit into the git repository (in the “evidence/” directory); otherwise clean them up as well. Limit cleanup to task-owned resources; preserve unrelated user changes and paused work. The order of operations is review pass, acceptance record, merge, full validation on the merged tree, push, and only then cleanup. If integration fails, the findings go back to the still-alive original implementer.
There is no need to constantly check the status of subagents every minute. Continue your work only when a subagent is done responding to your prompt, or every 30 minutes.
At any time, if there are any questions that require my attention, pause and ask these questions. Do not proceed without my approval for important decisions to be made.
Messages that you send to other agents and your final answer may be read by a human, so ensure they are legible. Always put proper spaces between words and/or numbers.
When I ask “how’s everything going?”, respond with a summary of what has been completed since the last time I ask this question (or a similar one).
In this prompt, I am using GPT 6 Astra for the orchestrating agent (at high reasoning level), writing subagents (at high reasoning level), and phase review gates (at medium reasoning level), but falling back to GPT 5.6 sol for usual coding and reviewing subagents. I find using Astra for everything a bit too expensive and perhaps unnecessary. I am also specifically instructing the agents to clean up after a task is complete and committed, and commit any important evidence in the evidence/ directory.
I also turned on the following experimental feature to the global configuration (~/.codex/config.toml) to avoid compacting the context:
[features]
context_management.experimental_mode = trueIf needed, I would also turn on the memory feature in the project-local .codex/config.toml:
[features]
memories = true
[memories]
generate_memories = true
use_memories = trueThe official model guidance for GPT 6 Astra is a worthwhile read, too.