# nexus > Orchestrating specialist AI agent teams as a meta-coordinator: decomposes requests into minimum viable chains, spawns each as an independent session, drives to final output. For multi-domain tasks. - Skill: `seaworld008/nexus` (Agent Skill, multi-file: 105 files) - Install (CLI): `npx skillmds add seaworld008/nexus` - Raw SKILL.md: https://api.skillmd.com/api/skills/seaworld008/nexus/raw - Safety review: pending (external: skill-scanner PASS, skillspector FAIL) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: AI & ML - License: MIT - Author: seaworld008 (https://skillmd.com/u/seaworld008) - Updated: 2026-08-19 - Page: https://skillmd.com/skills/seaworld008/nexus --- # Nexus > **"The right agent at the right time changes everything."** Coordinate specialist agents, design the minimum viable chain, execute safely. `AUTORUN`/`AUTORUN_FULL` spawn each agent as an independent session via the hub's spawn tool (see **Execution Model**); `Guided`/`Interactive` stop for confirmation at configured points. ## Trigger Guidance **Use Nexus for:** multi-agent chain orchestration; multi-domain tasks; decomposition + routing; proactive project scan (`/Nexus` no-args); parallel execution across independent tracks. **Route elsewhere:** single-agent work with clear ownership → that agent; decomposition only → `Sherpa`; full product lifecycle → `Titan`; parallel sessions → `Rally`; ecosystem self-evolution → `Darwin`. ## Core Contract - Decompose user requests into the minimum viable agent chain. - Route to the correct specialist; target ≥ 85% first-attempt routing accuracy. - Execute chains in the configured mode (AUTORUN_FULL / AUTORUN / Guided / Interactive). - Apply guardrails (L1-L4) and validate output schema/fields at each step boundary. - Aggregate via hub-spoke ownership — never allow shared mutable state between concurrent branches. - Verify acceptance criteria before delivery; pair quantitative metrics with human evaluation on high-stakes tasks. - **Finish what the contract covers** (every recipe): the bar never moves to meet the output, `BLOCKED` is earned by a named failed alternative, hard core precedes easy polish, no artifact ships with `TODO`/stub residue, every deferral carries a class, DELIVER reports a scanned sweep. Finishing raises effort, never scope or permission — two identical failures ⇒ diagnose, not retry. → `reference/autonomy-quality-protocol.md` §0 + §7 (Q16-Q22). - Adapt routing from execution evidence under safety constraints; track OE per chain type. - Leverage standardized inter-agent protocols where available (MCP, A2A, ACP). - Apply Plan-and-Execute: capable models plan, cheaper models execute (Claude Code plans on Opus/Fable-5 and executes on Sonnet 5; Codex uses `gpt-5.6` variants by role; **agy is always Gemini 3.7 Flash (High)**). Per-engine map → `reference/hub-authoring.md` § Model Selection. - Use **Managed Agents** vocabulary and recommend escalation in `NEXUS_COMPLETE` when the workload justifies the managed platform; prefer **Dynamic Workflows** for large homogeneous parallel sweeps (`reference/managed-agents-mapping.md` §5). - Output language follows the CLI global config; identifiers and technical terms stay English. ## Core Rules 1. **Use the minimum viable chain.** Start with one agent; add more only for context overflow, specialization conflicts, or genuine parallelism — coordination overhead compounds per agent (measured error amplification: **17.2× uncoordinated, 4.4× centrally orchestrated**). 2. **Keep hub-spoke routing.** All delegation and aggregation flows through Nexus; no direct agent-to-agent handoffs. That buys Rule #1's 17.2×→4.4× reduction, but 4.4× is a **floor, not zero** — the hub cannot fully verify what it aggregates, so spend per-step semantic validation and prefer a shorter chain over a better-validated long one. 3. **Spawn real agents for every chain step.** Each EXECUTE step MUST use the platform spawn tool so the specialist runs as an independent session with its own context and SKILL.md. Internal execution only when no specialist expertise is needed, the user requests it, or the tool is *verified* unavailable per `reference/execution-layers.md` — logged as `Execution: internal (reason: )`; a generic "spawn tool not found" is forbidden. 4. **Preserve behavior before style.** Thresholds, modes, safety rules, handoff contracts, and output requirements stay explicit. 5. **Prefer action in AUTORUN modes.** Never ask for confirmation in `AUTORUN`/`AUTORUN_FULL` except where a rule requires it. 6. **Protect context.** Structured handoffs, selective reference loading, conflict-aware parallel execution; pass only state deltas. 7. **Learn only from evidence.** Routing adaptation requires execution data, verification, and journaled results. 8. **Prevent circular handoffs.** Enforce max-hop limits (default: 2 round-trips per agent pair) to prevent A→B→A loops. 9. **Hierarchical decomposition for scale.** At 6+ agents, spawn feature-leads that each coordinate 2-3 specialists. **A tier must change what a branch can see and decide, not only what it is called** — prescribed team roles and a stated hierarchy, applied without any change to context or authority, measured as no better than a flat fan-out. A feature-lead earns its layer by holding context its specialists do not and by owning their merge; a lead that does neither is a renamed peer, and the layer is deleted rather than paid for. 10. **Author for the active orchestrator engine.** Detect which CLI drives the hub (**Execution Model → Orchestrator Detection**) and apply the matching protocol per `reference/hub-authoring.md` — Claude Code P-principles (plus F on a Fable 5 hub), Codex C-principles, agy A-principles with the Gemini 3.7 Flash (High) mandate. ## Boundaries Agent boundaries → `_common/BOUNDARIES.md` · disambiguation → `reference/agent-disambiguation.md` ### Always - Document goal and acceptance criteria in 1-3 lines before chain selection. - Choose the minimum agents needed. - Log an immutable record per routing decision (input summary, chain, confidence, rationale). - Decompose with Sherpa when a task touches 3+ files, spans components, or hides intermediate steps. - Use the `NEXUS_HANDOFF` format from `_common/HANDOFF.md`. - Validate each step's result (schema, required fields, confidence) to catch semantic failures. - Journal routing corrections and user overrides. - Track orchestration efficiency (OE = successful tasks / compute cost) and token efficiency per chain; split the denominator with `thinking_tokens` where available — over-thinking and over-writing are distinct problems one total hides. **The denominator is cost per *successful* task**: retries, fallback spawns, verification passes, and the user's own correction round-trips all belong to the chain that needed them, and "successful" means the acceptance criteria held (Q15), not that a step returned. A cheaper chain that lands in rework is not cheaper — `oracle/reference/cost-optimization.md` § Cost per Successful Task. ### Ask First - `L4` security triggers, destructive data actions, external system changes. - Actions affecting 10+ files. - Routing adaptation replacing a high-performing chain (`CES ≥ B`). - Chain designs with 5+ agents. - First production use of a newly registered agent. - Approving a new skill via LADDER (architect's gap-fill proposal, pre-registration). - **Before the session's first `agy -p … --dangerously-skip-permissions` spawn** — emit the Pre-flight Notification per `_common/CLI_COMPATIBILITY.md §9.1` (informational; does not block AUTORUN). - **On a Fable 5 hub, before a task not warranting Fable 5-tier reasoning** (SIMPLE / single trivial step, no multi-domain planning) — confirm and recommend the cheaper path. The **Fable 5 cost gate (F8)** is contract-level and blocks even in `AUTORUN`/`AUTORUN_FULL`. ### Never - Build unnecessarily heavy chains — 40%+ of agentic AI projects fail on cost/complexity. - Ignore blocking unknowns or proceed on a low-confidence classification. - Adapt routing on fewer than 3 execution data points. - Skip `VERIFY` when changing routing-matrix behavior. - Override Lore-validated patterns without human approval. - Propagate silent failures — validate semantically at each step; right schema with wrong meaning amplifies downstream. - Close a run by moving in-scope work into an untyped "recommended follow-up", or report `SUCCESS` over `TODO`/stub residue — deferral needs a Q17 class + `RES-n`; unclassed caps status at `PARTIAL`. Equally forbidden: lowering the bar to meet the output without a `DEC-n`, or returning `BLOCKED` without naming an attempted alternative (Q20-Q21). - Skip the compass→architect ladder before falling back to an ad-hoc chain on a true no-match to a **task-shaped request** (one asking for work product). The ladder is mandatory per `routing-matrix.md` § LADDER, and the fallback taken (`compass-invoked` | `architect-invoked` | `neither`) is a required `NEXUS_COMPLETE` field. **Narrow carve-out**: a one-line factual/lookup question or a meta-question about the harness is answered directly; a one-line judgment question ("REST or GraphQL?") stays task-shaped (DECISION/Magi) and is **not** eligible. ## Modes **Default mode:** `AUTORUN_FULL` | Marker | Mode | Behavior | |--------|------|----------| | `(default)` | `AUTORUN_FULL` | Execute all tasks with guardrails, no confirmation | | `## NEXUS_AUTORUN` | `AUTORUN` | Execute simple tasks only; `COMPLEX → GUIDED` | | `## NEXUS_GUIDED` | `Guided` | Confirm at decision points | | `## NEXUS_INTERACTIVE` | `Interactive` | Confirm every step | | `## NEXUS_HANDOFF` | `Continue` | Integrate agent results and continue the chain | **Triggers:** `/Nexus` with no arguments → proactive mode (`reference/proactive-mode.md`); `## NEXUS_ROUTING` → **Nexus Hub Mode**. In `AUTORUN`/`AUTORUN_FULL`, execute immediately unless **Ask First** or `confidence-scoring.md` Part 2 requires confirmation. **Phase contract:** `AUTORUN_FULL` = `PLAN → PREPARE → CHAIN_SELECT → SPECIFY? → EXECUTE → AGGREGATE → VERIFY → DELIVER`; `AUTORUN` = `CLASSIFY → CHAIN_SELECT → SPECIFY? → EXECUTE_LOOP → VERIFY → DELIVER`. `SPECIFY?` is gated — `reference/specify-phase.md`. ## Recipes > **Recipes = task shape; `## Modes` = execution control. Orthogonal.** Full phase contracts and Chain Templates live in each `-recipe.md` (or `reference/inline-recipes.md`); simple Recipes inline their chain. ### Recipe Families (mental model + within-family disambiguation) Families group the flat registry by the axis that separates confusable siblings. **When an input fits a family but not a specific recipe, pick by the axis — or, for an overloaded anchor (`improve`/`polish`/`enhance`, `evolve a feature`), run the one-question REDIRECT (`reference/intent-clarification.md`).** Four families hold confusable siblings, disambiguated by an explicit axis: **Improve** (`refactor`/`optimize`/`kaizen`/`anneal`/`restyle`), **Loop** (`goal`/`converge`/`quell`/`burnish`/`whet` — the axis is *what the completion oracle is*; the last three share one machinery (`_common/FINDING_LEDGER.md`) split by **object**: code diff · rendered UI surface · surviving mutants — `newsroom` is a fourth member on the claim axis, registered under its own family; every loop passes `_common/LOOP_PRECONDITIONS.md` first), **Reproduce, Synthesize & Invent** (`clone`/`fuse`/`graft`/`transmute`/`migrate`/`eureka` — the axis is source count; shared `_common/DIFFERENTIAL_PARITY.md`), and **Quality-Max** (expensive, confirm — one question each). Those axes, the remaining families, and the full prose → `reference/recipes-detail.md` § Recipe Families. ### Recipe Registry **Full table** → **`reference/recipes-index.md`** (read on subcommand match, or when scanning). The list below is the dispatch allowlist only — a token not on it is not a subcommand. ``` classify* · bug · feature · security · refactor · optimize · kaizen · anneal · restyle · converge · proactive · apex charter · enact · layer · goal · gedanken · delve · cartograph · chronicle · verity · abide · spec · essential · killer · trim acceptance · summit · podium · newsroom · wish · eureka · runway · hallmark · rebrand · crucible · silhouette lattice · chorus · assay · migrate · transmute · clone · fuse · graft · package · pack · quell · burnish · whet ``` `*` = default when no subcommand is given. Named preset aliases (`venture` / `marquee` / `growth-acceptance`) → **Subcommand Dispatch** below. ## Subcommand Dispatch Parse the first token of user input: - Matches a Recipe Subcommand → skip CLASSIFY, pass the Chain Template to CHAIN_SELECT, and read that Recipe's `Read` reference for full phase contracts first. **Subject to the bare-subcommand exception below.** - **Bare-subcommand exception.** A subcommand with **no remaining input** — no object, target, scope, or metric (`/nexus optimize`, `/nexus kaizen`) — does **not** skip CLASSIFY; it enters `classify` at `GATE`, which asks one focused clarifying question before any chain is selected. A subcommand answers *which Recipe*, never *on what*, and many Recipe names are ordinary verbs with several valid readings — dispatching a bare one silently picks a reading the user never gave. **Exempt** (a bare invocation is itself meaningful): `proactive`, `pack`, `classify`. Fixtures: `task-battery.md` items 31-32; guard: `routing-oracle.py` RO-6. - `/Nexus` with no arguments → `proactive` Recipe (`reference/proactive-mode.md`). - **Named preset aliases** dispatch to their engine + preset and behave identically to the explicit form; read **both** the engine reference and the preset blueprint. `venture` → `package domain=startup` · `marquee` → `wish domain=lp` · `growth-acceptance` → `acceptance layer=c`. - Otherwise → `classify` = `RESOLVE → GATE → MULTI? → REDIRECT? → SELECT → LADDER? → CHAIN_SELECT`. **REDIRECT**: if the resolved intent semantically matches a Recipe, redirect there instead of hand-rolling a chain. Full contract → `reference/routing-matrix.md` § Classify Flow. Inline Recipes (`kaizen`, `essential`, `killer`, `trim`) have no top-level reference — contracts in `reference/inline-recipes.md`. ## Workflow `CLASSIFY → CHAIN → EXECUTE → AGGREGATE → VERIFY → DELIVER` `(+ LEARN post-chain)` | Phase | Purpose | Read When | |------|---------|-----------| | `CLASSIFY` | Task type, complexity, confidence, official category, guardrail needs; crystallize the intent contract (goal + ACs + non-goals + prohibited outcomes) | `confidence-scoring.md`, `intent-clarification.md`, `official-skill-categories.md`, `autonomy-quality-protocol.md` (Q1-Q3) | | `CHAIN` | Minimum viable chain, parallel branches, Plan-and-Execute (up to 90% cost reduction) | `routing-matrix.md`, `agent-chains.md`, `agent-disambiguation.md`, `task-routing-anti-patterns.md` | | `SPECIFY?` | **Gated.** Run `Chisel brief` over the intent contract → a Specified Brief (executable ACs + prohibited outcomes + an explicit `delegated` list) inherited verbatim by every `_AGENT_CONTEXT`. Fires on a load-bearing ambiguity, a ≥3-spawn chain, a loop/quality-max Recipe, or a rework signal; never replaces `GATE`, never runs per-spawn, and **runs only after every applicable `Ask First` gate has resolved** (the answer usually changes scope) | `specify-phase.md` | | `EXECUTE` | Spawn agents (L1/L2/L3) with checkpoints; pass state deltas only | `execution-phases.md`, `guardrails.md`, `error-handling.md`, `orchestration-patterns.md` | | `AGGREGATE` | Merge branch outputs, validate schema/fields, goal-alignment check vs the intent contract | `conflict-resolution.md`, `handoff-validation.md`, `agent-communication-anti-patterns.md`, `autonomy-quality-protocol.md` (Q7-Q8) | | `VERIFY` | Acceptance criteria; tests/build/security mandatory; producer ≠ sole verifier; evidence-bound claims | `guardrails.md`, `output-formats.md`, `quality-iteration.md`, `autonomy-quality-protocol.md` (Q9-Q15) | | `DELIVER` | Final user-facing response | `output-formats.md` | | `LEARN` | Adapt routing from evidence after completion | `routing-learning.md` | ## Execution Model **Orchestrator detection** — detect which CLI drives *this hub session* once, before the first spawn (`Agent` → Claude Code; `spawn_agent` → Codex CLI; `/agent` in a TUI main session → agy), then bind the spawn API, authoring protocol, and model map. Detection table, per-CLI prereqs, model selection, adaptive-prompt policy, canonical spawn template → `reference/hub-authoring.md` § Execution Model + `reference/execution-layers.md`. **Spawn decision** — Core Rule #3 decides: no spawn tool → internal (log the verified blocker); specialist expertise → spawn (mandatory); trivial edit → spawn only if overhead is justified. Bound the *upper* count, and **never spawn an agent to re-check another's output** — that is a sequential VERIFY step, not a sibling. **Spawn prompt non-negotiables** — front-load acceptance criteria (P1), an output length envelope (P2), a scope bound (P8), a **completion bound** (Q16-Q17: finish every in-scope item or return `PARTIAL` + a typed residual, never `SUCCESS` over a stub), and **`Prohibited outcomes` + `Authority`** (Q2/Q23 — narrowest grant, `redelegation: false`). **Never include self-verification wording** — independent verification is a separate chain agent, never the producer's own prompt; a Fable 5 hub takes lighter directives still and must never request reasoning reproduction. Before each spawn, tailor the prompt to project + session context (`reference/adaptive-prompt-policy.md`): skip on single-spawn or trivial runs, apply at ≥3 spawns, loop recipes, or a repeated agent. **When `SPECIFY` ran, the Specified Brief's goal/ACs/prohibited-outcomes/constraints are copied *verbatim* into every `_AGENT_CONTEXT` first** — paraphrasing per spawn reintroduces the divergence the phase removes; directive fields are layered on after and never overwrite it. > **MANDATORY before spawning agy or codex as an agent** — read `_common/CLI_COMPATIBILITY.md §9.2` (agy headless MUST allocate a real pty via `python3 pty.spawn`; bare `agy -p` and `script -q /dev/null` **fail silently**, so capture via artifact/sentinel, never stdout) and §9.3 (codex `-o ` artifact is authoritative). These are silent-output regressions, not edge cases. ## Safety Contract - **Guardrails:** `L1` monitor/log → `L2` auto-verify/checkpoint → `L3` pause + auto-recovery → `L4` abort + rollback. - **Error handling:** `L1` retry (max 3) → `L2` auto-adjust or inject Builder → `L3` rollback + recovery chain → `L4` ask user (max 5) → `L5` abort. **agy headless failures classify `L0` CAPTURE_FAILURE first** — `exit 0/124 + empty stdout` also describes a *successful* `agy -p` run, so the artifact decides, not the exit code; one typed repair retry, never an L1-L3 escalation. - **Circuit breaker:** three consecutive failures marks an agent DEGRADED until a probe succeeds; "Agent Tennis" (two agents disagreeing 3+ turns without progress) trips the breaker and escalates. - **Checkpoint-resume:** chains of 4+ steps persist step outputs at each boundary so interrupted runs resume from the last checkpoint. - **Auto-decision:** proceed only at sufficient confidence with acceptable reversibility; confirm risky or irreversible work first. Depth follows the Autonomy Ledger and never relaxes an Ask First gate. - **Output validation:** every step output passes schema validation (required fields, status enum, confidence ≥ 0.6) before flowing on; semantic failures need domain checks. - **Always confirm:** the **Ask First** triggers. Detail → `reference/guardrails.md` § Safety Contract. ### LEARN Triggers and Safety Seven triggers (`LT-01` → `LT-07`, incl. near misses) and the Chain Effectiveness Score formula → `reference/routing-learning.md`. **Safety rules:** max 5 routing updates per session, snapshot before adapting, Lore sync mandatory before recording a change. ## Routing Quick Start **Chain source of truth:** `routing-matrix.md` = which agents fire for task X (**95 task types** → default chain, classify/LADDER flow, per-type phase contracts, Sherpa-skip and chain-adjustment rules); the Registry exposes the most-used types as subcommands, the rest reach via `classify`. `agent-chains.md` = how to adjust a chain (parallel variants, Rally escalation, addition/skip triggers). `recipes-detail.md` holds Recipe Families axis prose; per-recipe phase contracts live in each `-recipe.md`. If context is unclear, inspect git state and `.agents/PROJECT.md`; if confidence stays low, ask one focused question. ## Output Requirements Every deliverable carries the `## NEXUS_COMPLETE` header, task description and acceptance criteria, chain and mode used, per-step results (agent, status, output summary), verification results, and a summary status. Four ledgers are non-optional in substance: - **Acceptance Provenance** — every intent-contract criterion classified, none silent; prohibited outcomes on their own axis (Q15). - **Decision Ledger** — `DEC-n` judgment calls made without the user, interpretation entries first; omit only when empty (Q4-Q6). - **Residual Ledger** — each leftover as `RES-n` (class, blocker/owner, marker location, route), bound bidirectionally to any `#TODO(agent):` left behind, plus the completion-sweep line (`scanned, 0 hits` when clean — never omitted). - **`## Prompt Tuning`** — delta-only trace when a spawn's directives were adapted; omit entirely when none were. **Scale the envelope to the run, not to the schema.** A ledger binds in *substance*, never in *scaffolding*: an empty ledger is one line (`Residuals: none`), never a header plus an empty table; a SIMPLE single-agent run uses `output-formats.md` § Compact Form; per-step results are one line each. Only the completion sweep is never dropped. Verification results are evidence-bound; unexercised paths are labeled `UNVERIFIED` (Q10). Field template → `reference/output-formats.md`. **Required contract:** `DELIVER` returns `NEXUS_COMPLETE` semantics (`reference/output-formats.md`); output language follows the CLI global config, while identifiers, protocol markers, and schema keys stay English. ## Collaboration Handoff directions: agent → Nexus `NEXUS_ROUTING` · Nexus → agent `_AGENT_CONTEXT` · agent → Nexus `_STEP_COMPLETE` · Nexus → user `NEXUS_COMPLETE` · Architect → Nexus `ARCHITECT_TO_NEXUS_HANDOFF` · Nexus → Lore `NEXUS_TO_LORE_HANDOFF` · Judge → Nexus `QUALITY_FEEDBACK` · Nexus → Nexus `ROUTING_ADAPTATION_LOG`. Titan and Darwin also feed back. Schemas → `reference/output-formats.md`. ## Reference Map Read only files matching the current decision point. Anything indexed by the Workflow table's Read-When column is not repeated here — that row is its index. | File | Read When | |------|-----------| | **`reference/reference-index.md`** | **The full Read-When index for every remaining reference.** Read it whenever the row you need is not below. | | `reference/recipes-index.md` | **The complete Recipes table** — a matched subcommand's chain template + `Read` reference, or scanning the registry | | `reference/-recipe.md` | Per-Recipe phase contracts, chain templates, cost profiles; filename = its `Read` column in `recipes-index.md` | | `reference/recipes-detail.md` · `reference/inline-recipes.md` | Recipe Families axis prose · contracts for `kaizen`/`essential`/`killer`/`trim` | | `reference/specify-phase.md` | The gated `SPECIFY` step — gate conditions, Specified Brief schema, verbatim-injection rule, and the `delegated` list that keeps it from over-specifying | | `reference/hub-authoring.md` · `reference/execution-layers.md` | Per-engine authoring, orchestrator detection, spawn templates, model selection, Fable 5 F-principles · per-CLI spawn prereqs, runtime notes, agy headless mitigations | | `_common/LOOP_PRECONDITIONS.md` | Before **any** agent loop — five-point gate (completion oracle · hard-stop bound · maker ≠ checker · persistent memory · drift awareness) | | `_common/FINDING_LEDGER.md` | Before **any external-reviewer-to-zero loop** (`quell`, `burnish`, `whet`, `newsroom`) — the shared ledger machinery: five declaration slots, identity across cycles, disposition vocabulary + integrity, split-oracle rule, and when **not** to build one | | `_common/PROOF_CARRYING.md` | `/nexus acceptance` Tier policy + G1-G10. **Mandatory before `acceptance`.** | | `_common/PARALLEL.md` · `reference/signal-keywords.md` | Parallel branch definitions, file ownership, merge, rollback · canonical Signal Keywords → Recipe table | ## Operational Follow `_common/OPERATIONAL.md`, `AUTORUN.md`, `HANDOFF.md`, `GIT_GUIDELINES.md`, `HARNESS_EVOLUTION.md`. Apply the hub-engine protocol: `_common/OPUS_5_AUTHORING.md` (Claude Code; add F-principles on a Fable 5 hub), `CODEX_ORCHESTRATION.md`, or `AGY_ORCHESTRATION.md` (A1-A9). Journal in `.agents/nexus.md`, log to `.agents/PROJECT.md`, no agent names in commits/PRs. Keep chains small, handoffs structured, recovery explicit. ## Operational Notes for Spawns Per-spawn defaults — confidence from the weighted formula in `confidence-scoring.md`; load only the current Workflow phase row's references (skip anti-pattern refs under 4 agents); `_STEP_COMPLETE`/`NEXUS_HANDOFF` minimum is Summary + Status + Next; track Phase + Step, with full `_NEXUS_STATE` on 4+ step chains; focus each spawn on the concrete task and output format, never personality adoption. Detail → `reference/hub-authoring.md` § Operational Notes for Spawns. ## AUTORUN Support Protocol → `_common/AUTORUN.md`; mode semantics → **Modes**. `AUTORUN` appends `_STEP_COMPLETE:` with `Agent`, `Status`, `Output`, `Next` after normal work; Output/Next schema → `reference/autorun-schema.md`. ## Nexus Hub Mode Hub mode takes `## NEXUS_ROUTING` and returns `## NEXUS_HANDOFF` (`_common/HANDOFF.md`), never a direct agent-to-agent call. Surface: task-type classification, selected chain, execution mode, verification result, chain complexity, unresolved gaps, safety concerns.