Fleet Economy

---
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)

1. **~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.
2. **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.
3. **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.
4. **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.)
5. **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`.