| name | fleet-economy |
| description | Use when orchestrating any non-trivial multi-part task with subagents or model lanes — builds, audits, refactors, research sweeps, migrations — or when deciding which model tier handles a unit of work, how wide to fan out, or whether a heavy lane should itself delegate. Triggers include "orchestrate", "fan out", "route to cheap/heavy models", "workflowz", "MoE", "MLP", "fleet", or a task large enough to split across agents. |
| scope | harness |
| invocation | workflow |
Fleet Economy — MoE + MLP orchestration doctrine
Overview
The orchestrator conducts; it does not play every instrument. You are the INPUT LAYER — route, don't work. One expensive reasoning lane (you) decomposes, dispatches, verifies, and finalizes; agents do the rest, continuously and in parallel, the way a multitask orchestrator (Cursor / Hermes) keeps agents in flight the whole time. The failure mode is under-spawning — the main session quietly doing reads/analysis/edits it should have fanned out. Everything else is a lane. Match model cost to lane job: cheap models read/search/scan; medium/heavy models code and reason; the single hardest reasoning lane gets the most capable model. Every heavy lane you spawn must itself offload — recursively.
This is the single invoke-once surface for the fleet. It consolidates what was scattered across skills/opus-fleet/SKILL.md (substrate mechanics), _SYSTEM/config/cloud-fleet-models.json (the roster), and _SYSTEM/Scripts/fleet-router-mlp.mjs (the learned router). REQUIRED BACKGROUND for substrate/dispatch mechanics: opus-fleet.
The Iron Rules (violating the letter violates the spirit)
- ~20% orchestrator budget. You keep ONLY the load-bearing decisions: decompose the surface, write self-contained assignments, verify each result against evidence, run gates, commit/finalize. If a step is not one of those, it is a lane's job.
- Reads/searches/scans ALWAYS go to a cheaper model. File reads, greps, globs, doc scrapes, census, "where is X", "what does Y do" — never keep these for yourself, even the recon that scopes your own fan-out. The only reads you do are the artifacts a lane hands back and the gate output you verify.
- Coding/analysis/synthesis go to medium/heavy models (see roster). One unit of substantial work per lane; fan the same role across N instances when the work divides.
- Recursive offload is MANDATORY, not optional. Every large-model subagent you spawn (including heavy lanes) MUST itself offload its reads/searches/bulk to cheap lanes and reserve itself for the hard reasoning. State this in the assignment. A heavy lane that does its own grunt reads is a failure. (Leaf lanes that CANNOT spawn satisfy the spirit by surgical scoped reads — see the leaf-lane exception under the recursive offload contract.)
- Right-size, don't micro-task — but "trivial" is a NARROW, defined carve-out. Keep work inline ONLY when it meets ALL of: reads ≤1 already-known file, ≤~50 lines total, no grep/glob to locate it, no multi-stage bash. Everything else — 3+ file reads, ANY search to scope the work, a census, a multi-file edit — is a lane's job even when you could do it yourself. "I'll just read these myself, it's faster" is the exact reflex this rule kills; the undefined word "trivial" is the loophole that swallows the delegate-by-default rule, so it is defined here. Reserve inline for the genuinely one-shot edit.
Roster & tiers (the MoE) — canonical: _SYSTEM/config/cloud-fleet-models.json
Pick the tier by the SHAPE of the work, not by habit.
| Job shape | Tier | Models | Parallel cap |
|---|
| reads · search · scan · census · scrape · mechanical | CHEAP | deepseek-flash, composer, haiku, gemini-flash, gpt-mini | deepseek-flash ≤5, others wide |
| bulk analysis · digest · first-pass classification | CHEAP | deepseek-flash, glm-flash (glm-5-turbo) | ≤5 |
| code-gen · refactor · wiring · integration | MEDIUM/HEAVY | sonnet-5, glm (glm-5.1 workhorse), kimi-k2.7-code, minimax-m3 | minimax-m3 ≤3 |
| architecture · adversarial verify · hard synthesis | HEAVY | opus-4.8, glm-5.2 (glm-max), nemotron ultra/super | reserve for the single hardest lane |
| test authoring | DEDICATED | Tester agent (authoritative — never write tests yourself) | — |
Named-model → substrate map: cheap bulk = deepseek-flash (ollama-cloud deepseek-v4-flash); heavy synth = glm-5.2 (glm-max) / opus-4.8; code peer = kimi-k2.7-code; generalist = minimax-m3; reasoning burst = nemotron-3-ultra. Retired/forbidden: Codex, direct DeepSeek API, local Ollama SLMs.
Reserve the apex. Do NOT default every lane to a heavy model. One hard lane earns the strongest available governed heavy model; parallel verify/research/bulk goes cheap.
How to dispatch
Two surfaces, same discipline:
eval + agent() (fine-grained model routing, the workflowz path):
parallel([lambda s=s: agent(prompt, agent="deepseek-flash", label=...) for s in lanes]) — cheap legwork wide; agent(prompt, agent="mure-mechanic") for coding; agent(prompt, agent="mure-adjudicator") for adversarial verify; select apex_lane as an owner-selected available governed heavy lane, then use agent(prompt, agent=apex_lane) for the final pass.task tool — batch parallel subagents; pick agent per lane (explore/Tester/reviewer/task/sonic + the MURE roster).
Every assignment is self-contained: target files (≤3–5 explicit paths), the change with APIs/patterns, edge cases, observable acceptance. Instruct every lane: skip lint/format/gates — the orchestrator verifies once at phase end.
Dispatch reliability (a dead lane kills the habit)
A subagent that 429-dies teaches the orchestrator "delegation fails" — and it reverts to doing everything itself. Keep dispatch reliable so delegation stays the path of least resistance:
- The OMP
task role must route to a reliable, independent-quota default — never hard-pinned to a single provider that can hit a weekly/monthly cap. Provider fallback is wired in ~/.omp/agent/config.yml (retry.fallbackChains + retry.modelFallback), so a capped provider degrades to a healthy one instead of failing.
- Config changes are read at session start — an in-session
omp config set does NOT take effect until the next launch. If a provider caps mid-session, route explicit lanes to a known-healthy agent (deepseek-flash, or the GLM-free .claude/agents/* roster) rather than the capped default.
- When you see repeated
429 / rate-limit on a lane, that is a routing problem, not a reason to stop delegating — switch the agent, don't absorb the work.
Recursive offload contract (for heavy lanes)
When you spawn a heavy/reasoning lane, its assignment MUST include:
"Offload your reads/searches/scans to cheap sub-lanes (deepseek-flash/composer/haiku); reserve yourself for the hard reasoning. Do not do your own grunt reads."
Recursion follows the harness depth cap (main=0, child=1, …). GLM sub-orchestration (glm-max → glm-fleet.mjs) and nano-spawn are the deep paths (owner-gated, ≤5). Native OMP explore lanes are FLAT (no further spawn) — use them as leaves.
Leaf-lane exception. A lane whose harness exposes NO spawn/task surface — a depth-capped subagent spawned via eval agent() or an OMP explore lane — CANNOT recurse. It MUST instead do surgical scoped reads (grep-scoped, line selectors, per-file inspection, no bulk ingestion) and state in its output that it operated as a leaf. Rule 4 binds every lane that CAN spawn; a leaf satisfies the spirit by minimizing its own read footprint, not by recursing.
The MLP router (advisory)
fleet-router-mlp.mjs learns task-shape → substrate routing from the prediction-ledger (12 features → 8 hidden → 1 score; predictRoute(features, candidates)). It is ADVISORY — the 6-gate governance charter always overrides it; weight-persistence is gated (YURI_MLP_LEARN=1). Features are logged even when disarmed (offline replay). Treat its ranking as a hint, verify against evidence. Cold-start note: disk weights may lag the code version → first load re-initializes; warm from the ledger via train-fleet-router-from-ledger.mjs.
MURE role-cast (when the work maps to specialists)
For work that decomposes onto named specialists, cast to the MURE 20-role collective (helmsman/architect/steward · ideator/scout/synthesist/deliberator · engineer/mechanic/artificer/sentinel/kernelsmith · adjudicator/oracle/calibrator · archivist/chronicler · quartermaster). Governance 6-gate runs before dispatch. Use the mure-* agents directly in agent()/task().
Final pass
Close a substantial effort with an owner-selected available governed heavy lane as an APEX strategic/adversarial pass over the prepared package — and instruct it to use its OWN cheap sub-lanes (rule 4). Its refutations are the last gate before you finalize.
Rationalizations — STOP
| Excuse | Reality |
|---|
| "I'll just read these files myself, it's faster" | Reads always go cheap. Your context is for decisions, not grep output. |
| "This lane is heavy, it doesn't need to offload" | Rule 4 is mandatory. Heavy lanes recurse or they're wasting apex tokens on grunt work. |
| "Everything's important, use the big model" | Reserve the apex for the ONE hardest lane. Cost-match or you burn quota. |
| "One agent is enough here" | If it's substantial, split and fan wide; if it's trivial, do it inline. One-off lanes are the wrong size. |
| "I'll skip the final apex pass" | First-run success is a hypothesis. The apex adversarial pass is the last gate. |
Red flags — reroute
- You're about to
read/grep/glob more than to scope a dispatch → a cheap lane does that.
- A single lane is doing both grunt reads AND hard reasoning → split it; offload the reads.
- You spawned one subagent for divisible work → fan it wide or do it inline.
- Every lane is opus/glm-5.2 → you're not cost-matching.
Quick reference
Decompose → cheap lanes read/scan/scrape (≤5 deepseek-flash) → medium/heavy lanes code/analyze (each recursively offloading) → adversarial verify (mure-adjudicator) → you gate + commit → owner-selected available governed heavy lane apex final pass. You: ~20%. Roster: cloud-fleet-models.json. Mechanics: opus-fleet.
