Practical Multi-Agent Orchestration in Codex  🔗 **Source:** [Practical Multi-Agent Orchestration in Codex](https://twitter.com/pvncher/status/2080707291603407077/?rw_tt_thread=True) > [!note]+ Document Notes > --- > tags: [multi-agent-orchestration, delegation, context-inheritance, reasoning-effort, coding-agents] > author: "eric provencher" > source: X (formerly Twitter) > reference: https://twitter.com/pvncher/status/2080707291603407077/ > date created: 2026-09-07 > --- > > [!info] Generated analysis — not the author's words. Sections below are machine-written > > from the captured source. Only text inside `> [!quote]` blocks is verbatim from the author. > > Do not quote or attribute any other line to the named author. > # 🏷️ Title: Practical multi-agent orchestration in Codex > ## 🧭 Table of Contents > - [[#📝 Summary]] > - [[#📖 Main Content]] > - [[#🗒️ Notes]] > - [[#📚 References]] > - [[#🗣️ Paraphrase]] > - [[#📰 Newsletter]] > - [[#✅ Action Items]] > - [[#🧪 Hypotheses]] > - [[#📊 Methodology]] > - [[#❓ Questions]] > - [[#🔮 Future Research]] > - [[#💡 Implications]] > - [[#🧠 Learning Styles Assessment]] > - [[#📊 Accessibility Assessment]] > - [[#🌍 DEIB Assessment]] > - [[#✅ Logical Validity]] > - [[#🛡️ DARVO Analysis]] > - [[#🎯 Conclusion]] > - [[#🔄 Refactor Appendix — Practical multi-agent orchestration in Codex]] > ## 🔗 References > - Source thread: https://twitter.com/pvncher/status/2080707291603407077/ — published 2026-07-24. > - Author: eric provencher (pvncher), writing about Codex Multi-Agent V2 from an apparent insider position (the same voice that elsewhere says "we recently updated" the `$skill-creator` guidance). > - **Capture gap, verified against the markup:** the thread says roles work "like so:" and then shows them in an image. The stored HTML contains exactly one `<img>` — the cover — and zero links, so the role table itself is not in the captured text. The substance is recoverable from the surrounding prose and the standing-instructions block, but the exact role-to-effort mapping is inferred, not quoted. > ## 📝 Summary > - **What happened:** A practitioner walks through Codex's Multi-Agent V2 delegation model — coordinator, scouts, workers — and gives concrete defaults for reasoning effort, context inheritance, concurrency, and agent-to-agent messaging. > - **Why it matters:** It converts "use subagents" from a vibe into a configuration with named knobs: `reasoning_effort`, `fork_turns`, per-thread concurrency, and an explicit leaf boundary. The knobs are the contribution; the specific values are guesses. > - **Stakeholders:** anyone running parallel agents on real work, and anyone paying for the reasoning those agents spend. > - **Risks:** two safety-relevant behaviors are stated as configuration trivia rather than hazards — fresh-context agents silently drop inherited tool and safety restrictions, and context-inheriting agents can pick up their parent's delegation instructions and spawn further agents. > - **Bottom line:** the mechanisms and failure modes are genuinely useful and immediately testable. Every recommended value is asserted without measurement, and the piece is already dated by its own successor. > ## 📖 Main Content > **Delegation is now a first-class feature, not a prompt trick.** > > [!quote] ID:rw_01m1vp905kwgck6w6fcv12hnaz > > "GPT-5.6 Sol gets especially interesting when it has a team to work with. Codex's new Multi-Agent V2 tools give Sol and Terra a natural way to delegate tasks, share updates, and coordinate through complex tasks." > **Vary effort, not model family.** The recommended simplest setup keeps one model and adjusts reasoning effort per role, reserving the always-coordinating "Ultra" mode for high-stakes, ambiguous work where the extra depth is justified. > **Roles have distinct jobs.** The coordinator delegates, prevents duplicate investigation, and tracks state. Scouts investigate in parallel, read-only. Workers implement. > > [!quote] ID:rw_01m1vp905kwgck6w6fcv12hnaz > > "The coordinator acts as the primary delegator: it assigns substantive work, avoids duplicate investigations, and tracks what each agent is doing. Scouts can investigate in parallel, while workers can share implementation when responsibilities are clear." > **Agents talk to each other directly.** A separate messaging system with per-agent inboxes lets a scout hand findings straight to a worker instead of routing everything through the coordinator. > **Context inheritance is a dial with a sharp edge.** `fork_turns` decides whether an agent sees the parent's history. Inheriting helps it understand the goal; `"none"` gives a clean, focused assignment. Both settings carry a cost the piece states plainly and then moves past. > ## 🗒️ Notes > #### Modes and effort > - Ultra makes coordination the default; reserve for high-stakes or scattered-context work. > - For everything else, a short prompt or skill elicits the same collaborative behavior from a mid-effort model. > - Effort tiers as given in the standing-instructions block: `low` for read-only scouts, `medium` for routine implementation, `high` for harder problems. > #### Concurrency > - Configurable per thread; **defaults to four agents including the coordinator**. > - Within that budget the shape is flexible — one worker coordinating a scout and another worker, or the coordinator fanning out three scouts on separate questions. > #### Context inheritance (`fork_turns`) > - Inherited context conveys the broader goal and prior decisions. > - `fork_turns: "none"` yields a fresh, focused assignment. > - Fresh-context agents can still detect a dependency and contact a teammate on their own. > #### Two inheritance hazards > - An agent inheriting parent context may also inherit the parent's *orchestration* instructions, and start delegating itself. The fix is an explicit leaf boundary, quoted verbatim in the source. > - Fresh-context agents do **not** inherit task-specific tool or safety boundaries; those must be restated in the assignment. > #### Standing coordinator instructions > - Stay available to the user while delegating. > - Parallel read-only scouts at low effort with no forked context. > - Clear ownership, no overlapping assignments, leaf workers told not to delegate. > - Bring results together; keep approvals with the user. > ## 📚 References > - No external sources, benchmarks, or measurements are cited. Every number — the concurrency default of four, the three effort tiers — is presented as a product default or a recommended starting point, not as a result. > - Model names used without definition: GPT-5.6 Sol, Terra, Sol Light, Sol Medium, Ultra. These are the source's terms. > - The role table is an uncaptured image (see References note above). > ## 🗣️ Paraphrase > Codex can now run a team rather than a single agent, and the simplest way to use it is to keep one model family and change only how hard each member thinks. A coordinator hands out work, avoids sending two agents down the same path, and keeps track of who has what. Scouts go look things up in parallel and cheaply; workers build. Agents have their own inboxes, so a scout that finds something a worker needs can just tell them instead of bouncing it through the coordinator. You choose whether each agent inherits the conversation so far: inheriting explains the goal, starting fresh keeps the assignment clean. Both choices have a catch. An agent that inherits your context may also inherit your instructions to delegate and start spawning its own helpers, so tell leaf workers explicitly not to. An agent that starts fresh loses whatever tool and safety limits you had set, so restate them. Four agents including the coordinator is the default budget. Start with these settings and tune from there. > ## 📰 Newsletter > **Your subagents inherit more than context.** > Two failure modes in this Codex orchestration thread are worth knowing whatever tooling you use. First: an agent that inherits its parent's context can also inherit the parent's *instructions to delegate*, and start spawning helpers of its own. The fix is one line — tell leaf workers they're leaves. Second, and worse: agents started with fresh context **don't inherit your tool and safety restrictions**. The thread notes this in passing, as a configuration detail. It's the sentence in the piece I'd put on a sticky note. > The useful reframe is that delegation is now a set of dials — reasoning effort per role, context inheritance per agent, concurrency per thread — rather than a promptin  GPT-5.6 Sol gets especially interesting when it has a team to work with. Codex's new Multi-Agent V2 tools give Sol and Terra a natural way to delegate tasks, share updates, and coordinate through complex tasks. Ultra makes agent coordination the default and is best reserved for high-stakes work, where ambiguity or scattered context justify the added depth. For other tasks, a short prompt or skill can encourage the same collaborative behavior from Sol Medium, as it stays in conversation with you while organizing the work behind the scenes. With the right nudge, Sol can turn broad requests into focused assignments, bringing in other agents, and deciding when a problem calls for deeper reasoning. #### Match reasoning to the work While it's possible to have Sol delegate to another model like Terra, the simplest setup keeps one model family and adjusts only the reasoning effort, with dedicated roles like so: * **Scout — GPT-5.6 Sol Light.** Answer narrow, read-only questions: locate files, trace a code path, or find relevant tests. * **Worker — GPT-5.6 Sol Medium.** Implement scoped changes, run checks, or handle supporting work. * **Smart worker — GPT-5.6 Sol High.** Take on difficult implementation, resolve ambiguity, or coordinate help when useful. Treat these roles as useful defaults. Sol Light retains the judgment to find useful context without spending as much reasoning on discovery. #### Let the team coordinate The coordinator acts as the primary delegator: it assigns substantive work, avoids duplicate investigations, and tracks what each agent is doing. Scouts can investigate in parallel, while workers can share implementation when responsibilities are clear. Agents can also message one another directly through a common messaging system with separate inboxes. When a scout discovers something a worker needs, it can recognize the dependency and pass along its findings without waiting for the coordinator to relay them. Concurrency is configurable per thread and defaults to four agents, including the coordinator. Within that budget, a smart worker might coordinate a scout and another worker, or the coordinator could send three scouts to investigate separate questions. #### Choose what context agents inherit Forking conversation history helps agents understand the broader goal and earlier decisions. Starting with fork\_turns: "none" gives an agent a fresh, focused assignment instead. Fresh-context agents can still recognize when a teammate needs information and contact them independently. Agents that inherit their parent's context may also see its orchestration instructions. When an agent should remain a leaf, give it a short boundary: Complete this assignment directly. Do not spawn other agents; your parent's delegation instructions apply only to your parent. Fresh-context agents won't inherit task-specific tool or safety boundaries, so include any essential restrictions directly in their assignments. #### Capture the pattern in a skill A practical skill can give the coordinator a few standing instructions: Stay available to the user while delegating substantive work. Send focused, read-only scouts out in parallel with reasoning\_effort: "low" and fork\_turns: "none". Use reasoning\_effort: "medium" for routine implementation and reasoning\_effort: "high" for harder problems. Give each agent clear ownership, avoid overlapping assignments, and tell leaf workers not to delegate. Bring the results together and keep approvals with the user. #### Experiment with the knobs Start with these defaults, then experiment with reasoning effort, context inheritance, delegation authority, and how agents collaborate. The goal is to understand which settings help a team move the work forward without spending more reasoning than the task requires., Practical Multi-Agent Orchestration in Codex, eric provencher, 01m1vp905kwgck6w6fcv12hnaz.