OpenAI Codex

An accepted Codex run on 2026-09-21 exercised 21 worker invocations, parallel nodes, preflight, and commit. It did not exercise retries after a bad order or implementation defect, the dirty-baseline stop, push, or PR creation. The revised adapter below was checked against the collaboration tool schemas exposed on 2026-10-25 and the official documentation linked below; it has not been re-exercised end to end. Read your runtime's actual schemas and model list before dispatching.

Models

Example tier mapping checked on 2026-10-25 against official documentation and the session's advertised model overrides; availability and substitutions must be checked again at the start of each run:

Sol and Luna ids and efforts were advertised by that session's collaboration.spawn_agent schema. Official model documentation lists GPT-5.6 Terra as available during the rollout; its model reference supports medium reasoning effort. Terra was not advertised for subagent dispatch in that particular session; that does not establish its removal from Codex. Record the runtime's actual list, chosen mapping, every substitution, and every missing tier under Assumptions. If the runtime exposes no list, record that limitation and use only explicitly advertised choices; do not invent a model-discovery command.

When a tier is unavailable, move up one tier, never down, and state both the intended tier and the effective tier/model in the order. If the runtime does not offer Terra, a Medium order says "Medium unavailable; dispatched at Hard on gpt-6.1-sol". If no eligible model exists for Hard, report the limitation instead of assigning the mister or downgrading. Git remains a Git-role order even when its model must move up.

Trailer address: whatever your organisation uses for agent commits. Use the exact recorded model id as the trailer name unless a verified display name is available; do not manufacture one by expanding the id. The mister runs as Astra; never spawn it. Record the model and effort explicitly requested, plus any known configuration override, in the node's done line. A role name or worker self-description is not model identity; if the effective model is unknown, say so.

Capability check

Before adopting the shared workflow, check which tools this client actually exposes. Claude's allowed-tools frontmatter and this repository's agents/*.md are not evidence that a Codex worker has restricted tools.

Use direct file-reading/search tools when available. Otherwise dispatch read-only evidence collection to workers: literal listing, reading, or searching is Easy; interpretation uses the appropriate tier. Require the requested file contents or matches verbatim, with paths and line numbers; fetch chunks when necessary instead of accepting a summary as the file. This also applies to reading state on resume and inspecting captures. Every git-related operation still goes to a Git node.

A worker that retypes a file changes it. An Easy relay can truncate, duplicate or alter what it copies, so a transcript is never the file. Have the worker copy bytes with a literal command (cp, or sed -n '<a>,<b>p' for a range) into a capture, record its size and SHA-256, and decide from the hashes. Reading the skill's own references through workers is expensive: read SKILL.md and the references this run needs once, at the start, in one literal collector node, or have the launcher put them in the initial prompt. Resume reads the Log through a literal command that prints it, not through a worker's transcription of it.

Codex-orchestrated plans have tended to drop the spaces between words in the Log, orders and notes (maina1b2c3d,cleantree), which later readers and workers misread. Re-read each line you write against the Log rules in plan-and-orders.md before your next tool call.

Driving a Claude Code session as an implementer is a peer arrangement: follow peers.md, including its capability probe before any source edit.

Write the approved plan, orders, immutable reports and append-only metrics through a non-shell file tool, such as apply_patch, restricted to the state directory. Shell-only reading is therefore not itself a reason to stop: workers can supply the reads while the mister persists state without executing commands. If no non-shell state-writing tool is available either, report that specific limitation with an inline plan and orders. The September run establishes workflow coverage, not which file-access mechanism a current client exposes; do not infer that mechanism from its success.

Use the client's available planning and user-input controls; do not invent EnterPlanMode or ExitPlanMode calls. Approval still means an actual user response or existing session authorization, never a timeout or an unanswered question.

Dispatch

In the observed collaboration schema, spawn_agent takes task_name, message, fork_turns, model, and reasoning_effort. There is no agent_type or custom-agent selector. Task names use underscores, so the DAG node id lives inside the order text.

Example for a Medium node promoted to Hard because Medium is unavailable:

{
  "task_name": "n02_widget_model",
  "message": "<complete order above the cut line, canonical preamble included; state the Medium-to-Hard substitution>",
  "fork_turns": "none",
  "model": "gpt-6.1-sol",
  "reasoning_effort": "high"
}

Use fork_turns: "none" with model/effort overrides in this schema. Inline the canonical preamble, all needed context, and applicable user and repository constraints in the order; a clean fork must not depend on inherited conversation. Include relevant execution restrictions, verification requirements, and file-ownership boundaries explicitly rather than relying on a worker to know private instructions.

Call collaboration tools directly when the runtime requires it. Respect the slot limit your runtime advertises, including whether it counts the primary agent. Queue excess ready nodes without changing dependencies or overlapping ownership.

wait_agent can return for mailbox activity, user input, or a timeout; its summary is not the worker's report and does not prove completion. Read the delivered report and confirm status before accepting a node. Accept each completed node, then dispatch newly ready work: readiness, not waves. Prefer waits up to 60 seconds so progress updates remain possible.

For a missing verbatim Git report, use the runtime's continuation mechanism on the same worker to request it once. Check that it starts an idle worker: for example, the observed schema provides followup_task, whereas send_message alone only queues a message. An order gap requires revising the order and logging another dispatch. An interruption is not evidence that a command completed; reconcile before retrying mutations.

For a promotion required by the shared Recover rules, dispatch a fresh worker with the revised order, the failed criterion and its evidence, and the canonical preamble for the new role. A continuation does not establish a model change: use an explicit model/effort request and log it against the same node's remaining budget. Compare with the tier actually dispatched on the failed attempt; a Medium node already substituted to Hard has reached Hard, so requesting that same configuration again is not a promotion. Do not infer a stronger model from the new worker's self-description.

Engineering and independent review

Hard and Medium engineers receive behavioral outcomes, invariants, initial write ownership, and required verification. Inline the canonical Engineer preamble and the complete order, not a mechanical recipe in its place. Related repository exploration and additional focused verification stay within the user's access and execution constraints. Starting file lists do not limit investigation; extra writes still require an ownership amendment from the mister before editing them.

Use the runtime's continuation mechanism for findings outside ownership or a disproven assumption: the engineer supplies the evidence and proposed scope, and the mister checks active writers, semantic dependencies, and protected baseline content before amending the order. Investigation alone is not an implementation retry; a failed implementation attempt still counts toward the existing dispatch budget. Never grant permission through a worker message that the user has not already granted.

Do not downgrade an engineering node merely because the mister supplied exact code. Remaining design uncertainty and the consequences of a wrong choice determine the tier. Literal Easy and Git orders retain their strict command/edit boundaries; engineering freedom does not extend to running git or spawning workers.

Dispatch independent review in a fresh worker, separate from the implementer, using the canonical Reviewer preamble and the shared review workflow. It gets the user outcome, constraints, the assembled change, relevant repository guidance, and verification evidence, with freedom to inspect related unchanged code. Do not reuse a narrow one-question explorer prompt for whole-change review or prime the reviewer with the mister's diagnosis. Reviewers report concrete counterexamples, missing coverage, and evidence limits; reproduction belongs to a separate verification node. Use the shared review-tier policy and explain any permitted tier exception in the order.

When a reviewer has no non-shell file-reading tools, provide the full relevant source with the review package and a way to request further named files or matches from the mister. The mister dispatches a literal read-only collector and returns the raw evidence through a continuation of the same reviewer. Do not treat inability to inspect a dependency as a clean review, or silently give the reviewer verification-command privileges to compensate for missing file tools.

Read-only review is a role instruction in this direct-dispatch schema, not an enforced tool restriction. The Git workers collect revision metadata and diffs; engineers/reviewers never run Git to make their own review package. Include new task files and staged/unstaged content: a commit id alone does not identify an uncommitted change. Bind review and verification to the actual content and modes, and recheck affected evidence after a fix. Hashing a captured diff only checks transport integrity; it cannot establish that the current source or staged result still matches the reviewed change.

Enforcement and optional configuration

Official subagent documentation describes standalone custom-agent TOMLs, model overrides, and capability switches. Custom files can override a requested model or effort; account for them in the done line. They inherit parent permissions, so an explorer persona is not a separate read-only sandbox. The observed direct-dispatch schema cannot select such a file: do not claim an installed TOML is active without runtime evidence.

The configuration reference documents agents.enabled = false to disable multi-agent tools. It is not established here as a per-worker switch: disabling the mister's own agents would also prevent dispatch. The subagent documentation lists features.shell_tool = false for custom agents; that removes shell capability, not all possible write paths. No command-pattern allowlist or complete no-write fence for these roles was verified. Keep these restrictions labelled as instructions until the actual worker tool surface proves otherwise.

Keep any configured worker's role text verbatim from references/plan-and-orders.md; do not create a second preamble here. No custom TOMLs are shipped by this change.

Sandbox and environment

Use the session's actual permissions and network capabilities. Sandboxed sessions may be offline: fetch, push, and remote gh/glab operations need network access. An offline, unauthenticated, or approval-blocked Git node reports an environment failure; never simulate output or silently change permissions. Unclear verification failures use the shared read-only diagnosis workflow before edits or tier escalation. Do not kill an unrelated process to clear a port.

Independent acceptance and durable state

Follow evidence.md for every attempt's verbatim persisted report, dispatch/terminal metrics, content manifests, limits and resume reconciliation. A continuation for missing evidence counts as another dispatch when it starts a turn; a queued message alone does not. No worker, including Git, writes reports or metrics.

For required inspection, dispatch a fresh worker with fork_turns: "none", the canonical Inspector preamble and the minimal inspector package: literal criteria, owned/dependency paths, absolute directory, allowed commands, execution permissions and allowed test-output paths. Exclude Changes, implementer reports and the mister's diagnosis. Select the advertised Easy model (Luna here, substituting upward when unavailable) explicitly; do not select a nonexistent custom role parameter. Inspector non-writing, no-Git and command restrictions are instructions in this schema, not tool enforcement; only permitted test artifacts may be created. It never repairs source or spawns agents. Git-only criteria use a separate Git node; inspections are not recursively inspected. Bind PASS to current inputs and invalidate it on change, including resume/preflight mismatches.