Using GPT-5.6 Luna at Max in Codex

The useful pattern has three roles: Sol orchestrates, Terra handles subagent work inside the main task, and Luna handles bounded work in a separate delegated thread at XHigh or Max.

Sol decides what matters, breaks the work into clean packets, reviews conflicts, and owns the final answer. Terra coordinates as a subagent inside that task. Luna takes a self-contained packet in a separate thread and works it through at XHigh or Max reasoning effort.

That split gives each model the job it fits.

Luna is built for clear, repeatable, specific work with known success criteria. Think extraction, classification, transformation, structured summaries, and tightly scoped investigations. Sol belongs on ambiguous, difficult, high-value work that needs judgment and polish.

Reasoning effort changes how much work Luna spends on the packet. XHigh favors lower token use, cost, and latency. Max gives a genuinely hard packet more room to reason, with higher time and usage costs.

The decision isn't “Which model is best?” It is “Which model fits this piece of work, at which reasoning effort?”

Choose XHigh or Max

Choose XHigh when efficiency matters: it uses fewer output tokens, costs less, and starts responding faster. Choose Max when the task warrants deeper effort and the extra latency and quota usage are acceptable; fast mode can offset some of that delay.

Start with XHigh, then escalate to Max when the result misses explicit acceptance criteria. This lets the reader choose based on the packet instead of treating one effort tier as universally best.

Why use Luna as a delegated thread

A long Codex task usually contains several kinds of thinking.

Some decisions shape everything that follows: architecture, product tradeoffs, scope, and final synthesis. Those decisions belong with Sol.

Other tasks are hard but bounded: you know the inputs, the output has a defined shape, and the agent can verify whether it finished. Those are good separate Luna threads; the packet difficulty should determine whether the thread uses XHigh or Max.

Examples include:

• Scan several independent parts of a codebase and report findings against a fixed checklist.
• Triage a test failure with named files, reproduction steps, and required evidence.
• Compare two documents and produce a structured list of differences.
• Extract or classify records using a supplied schema.
• Transform source material into a required format without changing its meaning.
• Analyze logs for a specific failure signature and return supporting lines.

The assignment needs a boundary. “Investigate the repository” is too open. “Inspect the authentication tests, identify why these three cases fail, and return the smallest supported fix with verification” gives Luna something it can finish.

Max is useful when the packet is both bounded and genuinely hard. Easy extraction or routine transformation usually belongs at medium, high, or XHigh reasoning effort. Paying for Max on every Luna thread adds cost and delay without improving the handoff.

What DeepSWE says about bounded coding work

Luna Max gets more interesting when the packet involves serious coding work. DeepSWE broadens the case beyond extraction: its live leaderboard, updated July 25, 2026, ran 113 original long-horizon coding tasks across 91 repositories and 5 languages through the same mini-swe-agent setup.

Luna Max matched GPT-5.5 XHigh's point estimate and finished 6 points behind Sol Max. Its reported average cost was $0.61, compared with $8.39 for Sol Max, or about 13.75x lower. That is strong price and performance for a hard packet whose scope and acceptance criteria are already settled. Sol should still own architecture, conflict resolution, and final synthesis.

Read the result narrowly. DeepSWE is a third-party benchmark, not an OpenAI evaluation, and the confidence intervals overlap, so the small score gaps don't establish definitive rank differences. It used a standardized mini-swe-agent setup rather than Codex's native custom-agent and subagent orchestration. The tasks came from open-source TypeScript, Go, Python, JavaScript, and Rust repositories, which may not represent proprietary codebases or every task shape. DeepSWE also reports average per-trial cost. Real Codex usage and plan economics may differ.

The reliable split: Terra subagents, Luna delegated threads

Codex has two different delegation surfaces. Subagents are children inside the current multi-agent task and must coordinate with the parent. A delegated thread is a separate top-level Codex task with its own model, history, and lifecycle.

Use Terra inside Sol's subagent graph. OpenAI's Codex documentation recommends Terra for exploration, read-heavy scans, large-file review, and parallel workers that return distilled results to the main agent.

Use Luna in separate delegated threads for clear, repeatable work with known success criteria. Choose XHigh for efficiency or Max for the hardest bounded packets, then bring the result back to Sol for review and synthesis.

Why draw this boundary? In the X discussion, Codex DX engineer Eric Provencher said multi-agent v2 requires models that communicate well with one another and that Luna is not great at that. Pedro Nauck said Terra had worked for him and that Luna's fallback was easy to miss. Treat this as current implementation guidance, not a permanent model guarantee.

Configure Terra as the subagent default

Current Codex releases enable agent workflows by default, so you do not need to force the experimental multi_agent_v2 flag. If you want predictable routing, pin Terra under the documented agents settings:

[agents]
enabled = true
default_subagent_model = "gpt-5.6-terra"
default_subagent_reasoning_effort = "high"
max_concurrent_threads_per_session = 4

Terra is the pragmatic choice for supporting work inside Sol's task. Start at a lower effort when the scan is simple, and raise it only when the packet needs more planning or checking.

Teach Codex the routing boundary

Put the durable policy in the project's AGENTS.md:

## Model routing

- Keep Sol in the main thread for planning, judgment, conflict resolution, and final synthesis.
- Use Terra subagents for independent exploration, read-heavy scans, and supporting analysis that must return directly to Sol.
- Do not force Luna into the subagent graph. For a Luna-shaped task, write a self-contained handoff packet for a separate Codex task.
- Use Luna XHigh when efficiency matters. Escalate the separate Luna task to Max only when the packet is hard enough to justify the extra time and usage.
- Give every worker explicit scope, constraints, expected output, and done evidence.

Delegate Luna through a separate thread

For a Luna-shaped packet, have Sol prepare the handoff, then open a new Codex task and select GPT-5.6 Luna. The task is user-owned and visible as a separate thread; it does not behave like a child agent that automatically returns into Sol's run.

Prepare a self-contained handoff for a separate gpt-5.6-luna@max task.

Task: Inspect the payment webhook tests and identify the cause of the duplicate-event failure.
Constraints: Read only. Stay inside the webhook handler, its tests, and directly called helpers.
Done evidence: Name the failing path, cite the relevant files and behavior, propose the smallest supported fix, and list the verification command. Report blockers instead of guessing.

Paste that packet into the Luna thread. When it finishes, return its evidence or artifact to Sol's main thread for review. Separate threads make the model choice reliable, but they also make the handoff and return path your responsibility.

When Luna XHigh or Max is the right choice

Use a separate Luna thread when all of these are true, then select XHigh or Max based on the packet:

• The work is hard enough to justify extra reasoning time.
• The scope fits inside one clear packet.
• You can state success before the agent starts.
• The required evidence can be named.
• The result can be returned to Sol for review and final synthesis.

Good candidates include hard but bounded investigations, test-failure triage, document comparison, structured transformations, and independent codebase scans.

It also fits repeatable delegated work. If you keep writing the same brief, turn the stable parts into a reusable handoff template or skill, then open each Luna run as a separate task.

For parallel work, start with read-heavy packets. Each delegated thread should earn its place by removing a real bottleneck or protecting Sol from a large body of detail.

When not to use Luna, or when not to use Max

Skip Luna when the task needs Sol's judgment rather than bounded execution. For routine bounded work, use medium or high. Start hard work at XHigh, then move to Max only when deeper reasoning can materially change the result.

Keep Sol in charge of ambiguous architecture, product judgment, final editorial polish, and high-stakes synthesis. Luna can gather evidence for those decisions, but Sol should make them.

Avoid parallel subagents or delegated threads when each step depends tightly on the previous result. The coordination overhead can exceed the time saved.

Be careful with writes. Multiple agents editing the same files can produce conflicts or incompatible fixes. Prefer read-only investigation threads, isolated worktrees, or one clearly named owner who merges the result.

Don't delegate a task with no explicit scope or clear evidence of completion. More reasoning time can't repair a vague assignment.

Practical guardrails

A good Luna packet answers five questions before the thread starts:

1. What exact task should this agent finish?
2. Which files, documents, or systems are in scope?
3. What must it avoid changing?
4. What evidence proves completion?
5. Which missing decision should make it stop?

Keep permissions narrow. Terra subagents inherit the parent thread's permissions and runtime overrides unless a custom agent changes the sandbox mode. A separate Luna task uses its own thread settings; keep it read-only when the packet only requires inspection.

Separate the investigation from the implementation when conflicts are possible. Several agents can inspect independent areas in parallel, then Sol can choose one implementation path and assign one owner.

Require verification. A useful worker's report names what it inspected, what it found, what it changed if the brief allowed writes, how it checked the result, and what remains uncertain.

Budget the reasoning effort. Use medium or high for routine work. Start difficult bounded work at XHigh, then escalate to Max when the result misses explicit acceptance criteria or deeper reasoning can materially change it.

Finally, make Sol review the output. Delegation moves work. It doesn't move accountability.

The operating model

Sol orchestrates. Terra coordinates inside the task. Luna executes bounded work in a separate thread.

Use Terra for subagents that must communicate with Sol within a single coordinated task. Use Luna at XHigh or Max in separate delegated threads for self-contained packets. Run independent read-heavy packets in parallel, keep writes controlled, and define done evidence before any worker starts.

That is the useful split: Sol protects judgment and coherence, Terra handles in-task agent coordination, and Luna works through bounded difficulty without being forced into the subagent graph.

This recommendation combines current OpenAI Codex documentation with the observed multi-agent v2 behavior discussed by Codex DX engineer Eric Provencher. Model routing can change, so verify it again after Codex updates.

Sources

• OpenAI, Codex subagents
• OpenAI, Codex models
• OpenAI, Codex configuration reference
• Eric Provencher on Luna and multi-agent v2 on X
• DeepSWE leaderboard
• DeepSWE benchmark methodology
• OpenAI, GPT-5.6 launch