How to Use Luna Max in Codex: XHigh Subagents Under Sol High

Short answer: GPT-5.6 Luna with max reasoning can be a surprisingly capable Codex worker for bounded, repeatable, well-specified tasks. It may produce an accepted result at roughly the same rate as GPT-5.6 Sol at medium reasoning on your narrow task set—but that is a hypothesis to test, not a blanket model ranking. For recurring worker jobs, Luna XHigh is often the more economical setting to evaluate first; reserve Luna Max for cases where it produces a measured quality gain. Give every Luna worker a small surface area, explicit evidence requirements, a deterministic acceptance test, and a stopping rule. Keep Sol High responsible for decomposition, conflicts, judgment, and final review.

This guide shows the operational setup: what “Luna Max” means, where to place project instructions, how to define a project-scoped Luna XHigh worker and a Max variant, how a Sol High orchestrator should delegate and inspect work, and how to recover when a subagent stalls. It also includes marketer-oriented examples, copy-paste prompts, safety gates, current cost caveats, and a repository map. For broader model prompting, use DMT’s GPT-5.6 prompting and reasoning guide; this article deliberately stays focused on Codex subagents.

What “Luna Max” actually means

“Luna Max” is useful shorthand, but it combines two controls:

• Model identity: gpt-5.6-luna.
• Reasoning effort: max, where the selected surface and model support it.

It is not a separate model slug. OpenAI’s subagent documentation lists Luna as the choice for fast, narrowly scoped agents handling clear, repeatable, or high-volume work. The same page lists max and xhigh as effort levels for especially demanding reasoning when supported. OpenAI’s API guidance likewise says GPT-5.6 supports max reasoning and recommends reserving it for the hardest quality-first workloads.

In a UI, you may see a model name and an intelligence/reasoning label as separate selections. In a custom Codex agent file, the equivalents are model = "gpt-5.6-luna" and model_reasoning_effort = "max". Available labels depend on the product surface, account, workspace policy, and current rollout. If Luna or Max is absent from your selector, do not infer an entitlement from this article and do not invent a configuration that your account cannot run.

Can Luna Max really be on par with Sol Medium?

Sometimes, under constrained conditions. OpenAI does not claim that Luna Max is generally equivalent to Sol Medium. The defensible claim is narrower: a smaller model with more reasoning can sometimes satisfy the same acceptance test as a stronger model with medium reasoning when the task is bounded, the instructions are unambiguous, and the evaluator cares about the deliverable rather than the model name.

Conditions that make parity plausible

• The task has one clear outcome and a limited file, record, or source set.
• The worker does not need to discover the real objective while working.
• Inputs are complete, current, and accessible.
• Rules can be written as pass/fail checks rather than subjective preferences.
• The output has a defined schema, location, and evidence requirement.
• The worker is allowed to stop and escalate when evidence is missing.
• A stronger orchestrator reviews the result before it becomes authoritative or causes an external side effect.

Examples include extracting facts from ten known documents, checking a list of URLs, converting an approved outline into Gutenberg blocks, comparing a folder against a manifest, classifying inbox threads without changing them, or running a fixed QA checklist.

When Sol Medium or Sol High is the better owner

• The objective is ambiguous or changes as evidence emerges.
• The task spans several systems with conflicting states.
• There are consequential trade-offs involving brand, legal risk, security, money, or people.
• The work needs architecture, novel strategy, cannibalisation judgment, or reconciliation of contradictory evidence.
• Several workers edited overlapping files and someone must resolve conflicts.
• The final answer must distinguish verified facts, inference, uncertainty, and recommendation across a large context.

Sol is not only a “better writer.” Its value in this pattern is ownership: it defines the objective, chooses the decomposition, preserves boundaries, notices when a local answer fails the global goal, and signs off on the integrated result.

Validate parity with acceptance tests

Do not compare one impressive Luna answer with one weak Sol answer. Build a small evaluation set from the work you actually do.

1. Select 10–30 representative tasks. Include routine cases, messy edge cases, and a few deliberate blockers.
2. Freeze the contract. Use the same inputs, tool permissions, output schema, and acceptance criteria for both routes.
3. Blind the reviewer when practical. Judge the artifact before looking at the model.
4. Score acceptance, not elegance. Record pass/fail, factual errors, missing evidence, required rework, latency, and usage.
5. Set a routing threshold. For example, Luna becomes the default worker only if it remains within five percentage points of Sol Medium’s acceptance rate and does not increase severe errors.
6. Re-test after model, prompt, tool, or source changes. “On par” is workload-specific and time-bound.

A useful scorecard is: accepted without changes, accepted after minor edit, major rework, failed, or correctly escalated. Correct escalation should count as a safe outcome, not as failure. DMT’s guide to Luna cost per accepted result explains why raw token price is less useful than the cost of a deliverable that passes review.

Set up Luna XHigh and Max workers in Codex

Current Codex releases enable subagent workflows by default, and subagent activity appears in the desktop app, CLI, and IDE extension. You can request a subagent directly, or define a reusable custom agent. The reusable approach is safer when a task recurs because the model, effort, sandbox, instructions, and output contract do not need to be retyped each time.

1. Open the correct project

Start Codex in the directory that should provide file context. In the CLI, use the relevant working directory or --cd. In the desktop app or IDE, open the intended local project or workspace. Keep client projects separated: one client’s Gmail connection, WordPress credentials, exported analytics, or source files should not be silently available to another client’s worker.

2. Put durable boundaries in AGENTS.md

Codex reads AGENTS.md before work and builds the instruction chain once per run/session. Global guidance can live in the Codex home directory; project guidance is discovered from the project root down toward the current directory, with closer instructions taking precedence. Use AGENTS.md for durable project rules—not for a one-off task that belongs in the prompt.

# AGENTS.md

Project purpose: DMT editorial research and local content packaging.

Hard boundaries:
- Do not publish, schedule, syndicate, email, or post socially.
- Do not use secrets from skill or configuration folders.
- Treat WordPress, Gmail, analytics, and social tools as read-only unless the user explicitly approves a specific write.
- Preserve unrelated files and existing Git state.
- Every worker must return sources, files inspected, files changed, checks run, blockers, and confidence.
- A Sol orchestrator owns canonical decisions and final review.

Validation:
- Distinguish verified fact, inference, and recommendation.
- Prefer official OpenAI documentation for OpenAI product claims.
- Stop and escalate if a requested action would cross a permission boundary.

After changing AGENTS.md, start a new run or session so Codex rebuilds the instruction chain. OpenAI’s AGENTS.md documentation explains discovery and precedence.

3. Configure subagent defaults only if you want them

Project configuration can set a default subagent model and effort. For repeatable bounded work, use XHigh as the project default and escalate selected tasks to Max only after evaluation:

# .codex/config.toml
[agents]
enabled = true
max_concurrent_threads_per_session = 4
default_subagent_model = "gpt-5.6-luna"
default_subagent_reasoning_effort = "xhigh"

This does not force every worker to use Luna Max. Explicit spawn values take precedence, then agent defaults, then the parent’s settings. Keep the concurrency cap modest until you know your tasks are genuinely independent; more threads mean more token and tool work, and parallel writers can collide.

4. Define a project-scoped Luna XHigh worker

Create a standalone TOML file under .codex/agents/. This keeps the worker with the project instead of applying it to unrelated work.

# .codex/agents/luna-xhigh-worker.toml
name = "luna_xhigh_worker"
description = "Handles narrow, repeatable tasks with explicit evidence and acceptance tests under a Sol reviewer."
model = "gpt-5.6-luna"
model_reasoning_effort = "xhigh"
sandbox_mode = "read-only"

developer_instructions = """
Own only the bounded task assigned by the parent.
Read the stated scope, inputs, exclusions, output path, and acceptance test before acting.
Do not expand scope or make external changes.
Prefer targeted search and evidence capture over broad exploration.
If required evidence is unavailable, stop and return BLOCKED with the missing item.
Return: outcome, evidence, files inspected, files changed, checks run, open risks, confidence, and recommended next action.
Never claim completion without running the stated acceptance test.
"""

Read-only is the safest starting point for research, inventory, triage, and audits. Create a separate luna_max_worker file by changing only the name, description, and model_reasoning_effort = "max" when a representative evaluation shows Max improves the accepted-result rate. A worker that must edit local project files can use a workspace-write sandbox only after its file scope and validation commands are explicit. Do not give a generic worker unrestricted external tools “just in case.”

5. Request the worker explicitly

At most intelligence levels, ask Codex to delegate. A minimal request is:

Use the project-scoped luna_xhigh_worker for the source-extraction package described below. Keep the main Sol High thread as orchestrator and final reviewer. Wait for the worker, inspect its evidence, and do not integrate any claim that lacks a primary source.

If custom-agent files are not supported or visible in your current client, state the same model, effort, scope, sandbox, and output contract in the delegation prompt. Configuration improves consistency; it does not replace a good task contract.

Inspect, steer, stop, and resume subagent work

Do not treat a spawned worker as a hidden job. OpenAI documents Active and Done subagent activity, completed details, and thread inspection. In the CLI, use /agent to switch among active threads. You can ask Codex to steer a running worker, stop it, or close completed threads. The web activity sidebar may be read-only, so controls can differ by surface.

For the parent chat itself, use /resume while Codex is open or codex resume in the CLI. Remember that a resumed chat keeps its transcript and recorded working directory while Codex reads the current working tree. Recheck files that may have changed since the earlier turn.

The Sol High orchestrator/Luna worker blueprint

A reliable setup separates authority from throughput. Sol High owns the end-to-end outcome; Luna XHigh provides repeatable throughput; Luna Max is an escalation setting for a bounded worker package when tests justify the extra reasoning.

1. Sol defines the objective. State the desired outcome, why it matters, canonical sources, constraints, and exact approval boundary.
2. Sol designs the decomposition. Split work only where outputs are independent or have a clear dependency order.
3. Luna executes bounded packages. Each worker gets one task, a limited source/file set, an output schema, and an acceptance test.
4. Sol monitors evidence. Inspect progress when the worker reaches its first checkpoint, not only at the end.
5. Sol integrates. Resolve contradictions, deduplicate findings, protect canonical ownership, and reconcile overlapping edits.
6. Sol final-reviews. Re-run critical checks, verify citations against primary sources, and label unresolved uncertainty.
7. A human approves side effects. Publication, email, social posting, destructive actions, spend, and sensitive account changes remain behind explicit approval.

This is an agent-harness pattern: the important controls are not only the model names but the retained objective, bounded tools, state receipts, acceptance checks, and correction path. See DMT’s deeper guide to agent-harness reliability controls.

Parallel or sequential?

Work shape	Run pattern	Reason	Control
Five independent source ledgers	Parallel	Read-heavy, no shared writes	One source domain or topic per worker
Inventory, then duplicate decision	Sequential	Decision depends on the inventory	Do not start drafting before the gate
Separate file audits	Parallel	Disjoint file scopes	Explicit ownership map
Several edits to one article	Usually sequential	Shared-write conflicts and lost context	One writer, separate read-only reviewers
Research plus copy drafting	Sequential or staged	Draft must use verified ledger	Freeze sources before prose

OpenAI specifically recommends parallelism for read-heavy work and caution for write-heavy work. Parallel execution reduces wall-clock time only when coordination and conflict resolution do not consume the savings.

A handoff schema that prevents vague “done” messages

STATUS: COMPLETE | PARTIAL | BLOCKED
TASK_ID:
OBJECTIVE:
SCOPE_USED:
EXCLUSIONS_RESPECTED:
OUTCOME:
EVIDENCE:
  - source/file/record
  - exact supporting detail
FILES_INSPECTED:
FILES_CHANGED:
COMMANDS_OR_TOOLS_RUN:
ACCEPTANCE_TESTS:
  - test: PASS | FAIL | NOT RUN
OPEN_RISKS:
FACT_CONFIDENCE:
RETRY_ATTEMPT:
RECOMMENDED_NEXT_ACTION:

The parent should reject a receipt that says “research complete” but lacks exact sources, or “tests pass” without naming the test. Evidence receipts make work resumable and let another reviewer reproduce the decision.

Stopping, retry, and no-stall rules

• Stop on acceptance: once all required tests pass, return the receipt; do not polish adjacent work.
• Stop on authority: if completion requires a new permission, external write, destructive action, or account change, return BLOCKED and name the required approval.
• Stop on missing evidence: do not replace a missing primary source with social confidence.
• One focused retry: the orchestrator may correct a specific failed criterion once with tighter input or a smaller scope.
• No identical loop: if the same blocker repeats, escalate to Sol rather than launching the same worker again.
• Progress checkpoint: for a bounded task, require the first evidence or file inventory before a team-defined time budget expires.
• Interrupt drift: if the worker starts broad research, unrelated edits, or speculative recommendations, steer once; if drift continues, stop it.

Contextual model-routing table

Task shape	Recommended route	Why	Failure or escalation rule
Clear extraction, classification, URL checks, manifest comparison	Luna medium first; Luna max if evals show gain	Fast, narrow, repeatable	Escalate missing/contradictory evidence to Sol
Bounded implementation with exact files and tests	Luna max worker	More reasoning inside a controlled surface	Escalate after one failed focused retry or unexpected architecture
Large read-heavy exploration	Terra medium/high or parallel Luna workers	Balances scan depth, speed, and synthesis	Sol resolves cross-source contradictions
Ambiguous objective, architecture, canonical SEO decision	Sol Medium	Needs planning and judgment	Move to Sol High if risks or contradictions remain material
High-stakes final review, security, legal/brand-sensitive decision	Sol High plus human approval	Quality-first reasoning and accountable review	Do not automate the final side effect
Independent read-only QA checks	Parallel Luna max workers, Sol integration	Clean decomposition and evidence receipts	Stop if scopes overlap or results conflict

Start with medium reasoning as the baseline when you do not have evidence that max helps. Higher effort increases response time and token use. “Max everywhere” is not a reliability strategy; it can be an expensive way to hide an unclear task contract.

Five practical workflows for marketers and operators

1. Tayeeb OS inventory and routing

Sol owns: the definition of Now, Review, Waiting, and Done; which source project remains authoritative; and whether a status conflict requires human attention.

Luna Max worker: read a bounded set of project receipts and manifests, extract current status, last evidence date, next action, and blocker into a fixed table. It must not move, rename, merge, delete, or “clean up” projects. Acceptance means every row has a source path and no unsupported status change. Sol then reconciles duplicate or stale records and updates the canonical hub only if that write was in scope.

2. DMT SEO research package

Sol owns: search intent, duplicate/cannibalisation judgment, primary keyword, editorial angle, and final fact review.

Luna Max workers: one can extract first-party product facts into a ledger; another can summarize GSC/GKP exports; another can map internal-link candidates. All stay read-only. Acceptance requires exact URLs, capture dates, query provenance, and confidence labels. Sol rejects social claims that lack a primary source and decides whether the result is a new URL, refresh, or merge. This complements DMT’s broader Codex workflows for marketers.

3. WordPress content packaging without publishing

Sol owns: canonical decision, outline, claim ledger, final article integration, and the publication gate.

Luna Max worker: convert an approved outline and verified ledger into Gutenberg-compatible blocks in a new local folder; generate metadata, FAQ, link plan, and deterministic HTML checks. It must not authenticate to WordPress, create a draft, upload media, schedule, publish, or syndicate. Acceptance includes balanced block comments, source-link presence, distinct anchors, correct heading order, and a no-publication receipt. A future WordPress action requires the publisher to approve the final body, proposed canonical URL, metadata, internal links, author/category, and rights-cleared image.

4. Gmail read-only triage

Sol owns: account selection, date/query scope, prioritisation logic, sensitive-topic handling, and any reply recommendation.

Luna Max worker: search or classify only the authorized mailbox and return thread links, senders, dates, category, urgency reason, and suggested next action. It must not reply, forward, draft, label, archive, delete, mark read, download sensitive attachments, or cross into another account. Connector permissions remain tool-specific; a read-only prompt is not a substitute for verifying the actual tool surface. Sol reviews the queue, and a human explicitly approves any message or state change.

5. Project and file audit

Sol owns: which directories are in scope, what “duplicate” means, and what remediation—if any—is authorized.

Luna Max workers: inventory disjoint directories, hash or classify files, identify missing manifests, and produce read-only findings. They do not delete, move, rename, reset Git, or infer that old means disposable. Acceptance requires resolved absolute paths, scope counts, exceptions, and reproducible commands. Sol combines the inventories and presents recommendations; a human approves material cleanup separately.

Copy-paste Sol High orchestrator prompt

You are the Sol High orchestrator and final reviewer.

Objective:
[state the concrete deliverable and why it matters]

Authoritative scope:
- Project/root: [absolute path or named project]
- Allowed sources: [list]
- Allowed files/records: [list]
- Exclusions: [list]

Mutation boundary:
- [read-only | local workspace edits only]
- No external writes, publishing, email, social posting, spending, destructive changes, or permission expansion unless explicitly listed above.

Delegation:
- Use Luna XHigh workers for bounded packages that can be independently accepted.
- Escalate a worker to Luna Max only when the acceptance test or edge-case risk justifies it.
- Give each worker one task, its exact inputs, output path/schema, and acceptance test.
- Prefer parallel work only for independent read-only or disjoint-file tasks.
- Wait for the required workers, inspect their evidence, and resolve conflicts yourself.

Worker packages:
1. [task, inputs, output, acceptance test]
2. [task, inputs, output, acceptance test]

Stopping and recovery:
- Require an evidence checkpoint before broadening work.
- Steer a drifting worker once.
- Permit one focused retry for a failed criterion.
- If the same blocker repeats, stop and escalate; do not loop.
- Treat missing authority or evidence as BLOCKED, not as permission to improvise.

Final review:
- Re-run critical checks.
- Cross-check material product facts with primary sources.
- Separate verified facts, inference, and recommendation.
- Return a final receipt listing outputs, evidence, checks, unresolved risks, and exact approval still needed.

Copy-paste Luna XHigh or Max worker prompt

You are the Luna bounded worker at the reasoning effort assigned by the Sol High parent.

Task ID: [ID]
Objective: [one concrete outcome]
Inputs: [exact sources/files/records]
Output: [exact file or response schema]
Acceptance tests:
- [test 1]
- [test 2]
- [test 3]

Boundaries:
- Own only this task.
- Do not broaden research or modify adjacent files.
- Do not make external writes or request broader permission.
- Preserve secrets, account separation, unrelated files, and Git state.
- Use primary sources for material product facts.
- If required evidence is missing or contradictory, stop and return BLOCKED.

Progress:
- First return or record the source/file inventory.
- Continue while useful evidence is accumulating.
- If an approach fails, retry once only when the correction is specific.

Receipt:
Return STATUS, OUTCOME, EVIDENCE, FILES INSPECTED, FILES CHANGED, TOOLS/COMMANDS, ACCEPTANCE TEST RESULTS, OPEN RISKS, CONFIDENCE, and RECOMMENDED NEXT ACTION.
Do not claim completion until every required acceptance test has a recorded result.

Cost, tokens, latency, and limits

Separate two billing contexts.

Codex usage and credits

Codex usage depends on model, context, reasoning, tools, retrieval, and caching; prompt length alone is not a reliable estimate. OpenAI’s current Codex rate card lists GPT-5.6 Luna at 5 input credits, 0.5 cached-input credits, and 30 output credits per million tokens, compared with Sol at 125, 12.5, and 750. These are Codex credits, not dollars. Subagents consume more tokens than comparable single-agent runs because each worker performs its own model and tool work. Check the current Codex pricing and usage documentation, the usage dashboard, or /status rather than assuming a plan allowance from this article.

For a deeper Sol-specific discussion, see DMT’s Sol Codex usage-limit guide.

API pricing

When Codex or an application runs through an API key, standard API pricing applies. As captured on 9 August 2026, the Luna model page lists $0.20 input, $0.02 cached input, and $1.20 output per million tokens. It also lists a 1,050,000-token context window and 128,000 maximum output. Requests above 272K input tokens are priced at 2× input and 1.5× output for the full request, and cache writes are billed at 1.25× uncached input. Recheck the official Luna model page before budgeting. DMT’s current GPT-5.6 API pricing context covers the broader change history.

There is no honest fixed “Luna Max takes X seconds” promise. OpenAI says higher reasoning effort increases response time and token usage. Measure end-to-end latency, accepted-result rate, retry rate, and reviewer time on representative tasks. The lowest token price can lose if it causes repeated rework; the highest reasoning level can lose if the task never needed it. DMT’s Luna automation cost-control playbook extends this accepted-result approach.

Safety and permission design

Subagents inherit the parent sandbox and permission mode unless a custom agent narrows its configuration. In hosted ChatGPT Work, subagents use the tools available to the parent and website/connector permissions remain tool-specific. In a non-interactive run, an action that needs a fresh approval fails rather than waiting invisibly. Choose the parent permission mode before delegation and design the worker so expected work fits inside it.

• External writes: email, WordPress, social, CRM, Drive comments, calendar actions, or deployment need explicit scope and approval. A worker producing a local draft is not authorization to upload it.
• Destructive actions: deletion, bulk move/rename, Git reset, database mutation, or permission weakening should not be delegated as routine cleanup.
• Sensitive data: never paste API keys, OAuth tokens, mailbox exports, client PII, or secrets into prompts or receipts. Give workers the minimum source set.
• Account separation: name the authorized client/account and fail closed if the connected session is ambiguous.
• MCP and connectors: expose only relevant servers/tools. A community MCP server is not automatically safe, maintained, production-ready, or approved for client data.
• Approvals: treat a technical sandbox, a connector permission, a user instruction, and an organizational policy as separate layers. Passing one does not override the others.
• Social evidence: X posts can reveal emerging issues but cannot establish product configuration, price, or availability.

Useful GitHub repositories—and what they do not prove

Repository	Owner and purpose	Relevance	Authority/maintenance caveat
openai/codex	OpenAI; open-source Codex CLI implementation	Inspect releases, configuration behavior, source, issues, and security policy	Official repository, but code or an issue is not proof that Luna/Max is available to every account or UI
openai/openai-python	OpenAI; official Python client for the OpenAI REST API	Typed Responses API calls, streaming, retries, sync/async automation, and API-key implementations	Not a Codex subagent runtime; library support does not prove product-surface availability
openai/openai-agents-python	OpenAI; Python Agents SDK for multi-agent workflows	Programmatic agents, tools, guardrails, handoffs, human-in-the-loop, sessions, and tracing	Separate from Codex custom subagents; do not copy SDK configuration into Codex TOML
openai/evals	OpenAI; framework and registry for LLM/system evaluations	Build the acceptance tests used to decide whether Luna Max matches Sol Medium on a workload	API runs can cost money; dashboard and repository workflows may evolve independently
openai/openai-cookbook	OpenAI; API examples and guides	Context engineering, eval, tool, and automation patterns	Examples are educational, not a compatibility contract; verify current API docs
modelcontextprotocol/servers	MCP steering group; reference MCP server implementations	Understand MCP patterns and tool boundaries	Not OpenAI-owned, not evidence of Luna support, and explicitly not a set of production-ready servers

Also avoid conflating Codex subagents with the Responses API multi-agent beta. They are related orchestration ideas on different surfaces with different configuration, billing, and operational controls.

When not to use Luna Max

• When Luna at medium or high already meets the acceptance threshold; max adds latency and tokens.
• When the task is too small to justify delegation overhead.
• When the objective is ambiguous and the worker would need to invent priorities.
• When several workers must edit the same artifact without clear sequencing.
• When the action is irreversible or externally visible and no human approval is available.
• When the task needs extensive cross-system judgment, sensitive account handling, or a high-stakes final decision.
• When you cannot observe progress, reproduce evidence, or inspect the result.
• When a missing primary source makes the answer inherently speculative.

A single Sol Medium run can be cheaper and safer than spawning several Luna Max workers for a tightly coupled problem. Delegation is an architectural choice, not a ritual.

Active-subagent inspection and stall-recovery checklist

• Confirm the expected worker name, model, effort, and task ID.
• Confirm the worker received the intended project path, inputs, exclusions, output path, and acceptance tests.
• Check the Active/Done view or use /agent in the CLI.
• Inspect the first evidence checkpoint: files found, sources opened, or records counted.
• Verify that any tool request matches the declared scope and account.
• Watch for broad searching, adjacent edits, repeated commands, fabricated completion, or the same blocker appearing twice.
• If direction is wrong, send one precise steering message that names the failed criterion and corrected scope.
• If the worker needs new authority, stop and escalate instead of expanding permissions.
• If one focused retry fails, route the task to Sol Medium/High or redesign the decomposition.
• Before integration, read the receipt and open the cited evidence; do not accept only the parent summary.
• Re-run critical acceptance tests in the Sol thread.
• Close completed threads and record the final artifact paths and unresolved risks.

Frequently asked questions

Is Luna Max an official model name?

No. It is shorthand for the GPT-5.6 Luna model with max reasoning effort. Model identity and reasoning effort are separate controls.

Is Luna Max always as good as Sol Medium?

No. It can be competitive on bounded, repeatable, well-specified tasks, but you must validate that claim on representative acceptance tests. Sol remains the safer owner for ambiguity, architecture, conflicts, high stakes, and final review.

Where do custom Codex subagent files go?

OpenAI documents personal agents under ~/.codex/agents/ and project-scoped agents under .codex/agents/. Each standalone TOML file needs a name, description, and developer instructions; it can also pin model, effort, sandbox, MCP servers, and skills.

Does AGENTS.md select Luna Max?

AGENTS.md is best for durable instructions and project boundaries. Pin model and reasoning in the custom-agent TOML or appropriate Codex configuration. You can also ask for a model/effort explicitly when delegating.

Should I run several Luna Max workers in parallel?

Only when the tasks are independent, usually read-heavy or restricted to disjoint files. Use sequential stages when one result gates another or several agents would write the same artifact.

How do I see what a subagent is doing?

Use the subagent activity shown in supported desktop, CLI, or IDE surfaces. In the CLI, /agent switches among active threads. You can ask Codex to steer, stop, or close a worker. Exact controls differ by surface.

What if a Luna worker stalls?

Inspect whether it has produced real evidence. Send one precise correction, permit one focused retry, then stop and escalate if the same blocker or drift repeats. Do not create an infinite retry loop.

Does a read-only prompt guarantee safety?

No. Verify the actual sandbox, permission mode, connector/tool permissions, selected account, and custom-agent configuration. Instructions, technical permissions, and organizational authorization are separate controls.

Are Codex credits the same as API pricing?

No. Codex credits measure product usage, while API-key runs are billed at standard API token/tool rates. Check the current official pricing page for the surface you use.

Bottom line

Luna works best as a disciplined specialist, not a cheaper imitation of Sol. Use XHigh as a serious repeatable-worker candidate and Max when the acceptance data shows that the extra reasoning is worth its cost and latency. Give it a narrow task, constrained tools, exact evidence, a fixed output schema, a measurable acceptance test, and permission to stop. Let Sol High own the system: objective, decomposition, conflict resolution, integration, and final review. When the problem becomes ambiguous, coupled, high-stakes, or externally visible, escalate.

---

Methodology and editorial accountability

This DMT guide was prepared from live OpenAI documentation captured on 9 August 2026, official repository README pages, a refreshed DMT WordPress/topic-graph inventory, DMT Search Console data, Google Keyword Planner, and a bounded public X discovery check. Product facts are separated from operational recommendations. The “on par” framing is a testable recommendation, not an official benchmark claim. X posts were recorded for launch context and practitioner discovery only; no product fact depends on them.

About Digital Marketer Tayeeb: DMT publishes implementation-focused digital marketing and AI workflow guides for practitioners. The accompanying editorial package includes the source ledger, duplicate decision, visual provenance requirements, and quality audit so an editor can reproduce the evidence behind this article.

Published on Digital Marketer Tayeeb on 9 August 2026. No social post was created. Authorized screenshots were unavailable, so the live article contains no fabricated visuals or featured image.