cost-tiered-orchestration

name	cost-tiered-orchestration
description	Use when about to spawn Agent/Workflow subagents, fan out parallel work, or pick a model for delegated work — especially before any multi-agent fan-out, or whenever a task might run on a cheaper model tier than the default.

Cost-Tiered Orchestration

Overview

Every subagent/Workflow call inherits the caller's model unless you set one. Inheriting an expensive tier for rote work is the single biggest hidden token cost in agentic work. Pick the cheapest tier that can reliably do each phase, state the tier split BEFORE the fan-out, and cap concurrency.

Routing easy work to cheap models is the #1 production cost lever — sending a one-line extraction to a frontier model overpays ~10× (ayautomate 2026). Anthropic's own anchor: orchestrator-worker fan-out ≈ 15× the tokens of a single exchange, ≈4× a single-agent run. The architecture only pays for itself when work genuinely parallelizes AND the tiers are right.

The Iron Rule

No agent() / Agent call without an explicit model:. No fan-out without a stated tier split.

Inheriting the default is not a choice — it's the failure. State the split in the plan so the spend shape is visible before it runs.

Tier selection

Tier	Use for	Never for
haiku	file inventories, grep/discovery, mechanical extraction, listings, simple summaries, doc-link checks	anything needing judgment or synthesis
sonnet	the BULK of any workflow: map/audit readers, fix implementers, routine + adversarial verifiers, test writing, doc updates	hard architecture/security reasoning
opus	planning, hard debugging, architecture/security review, high-risk changes, the synthesis/chairman seat	rote discovery, mechanical verification
fable	ONLY orchestration + the 3-4 synthesis/review seats where a missed nuance costs real money; ~2× tokens	a default. Currently unavailable except via cursor at excessive cost → say so and use opus

Shape: many cheap discovery/verify seats + a few strong synthesis seats. This maps to the proven Thinker/Worker/Verifier split — strong planner burns tokens thinking, cheap executor runs the loop many times, cheap verifier checks (smartmobilehouse 2026).

Cheap-first → verify → escalate

The workhorse cost pattern. Run the cheap tier first, verify with a rubric/skeptic (also cheap), escalate to a stronger tier ONLY on failure. Do not send everything to the top tier "to be safe" — that IS the waste.

Hard caps (surface failures, don't amortize them)

• Concurrency cap ≤ ~16 agents on the same API (the Workflow tool auto-caps at min(16, cores-2); a naive parallel() of 45 tripped the Anthropic rate limit — the verify phase then returned 0 confirmed, which is UNVERIFIED, not clean). Stagger large fan-outs in waves of ~10.
• Depth ≤ 2 (parent → subagent → one more). Depth 3 means the orchestration is wrong.
• haiku never spawns subagents. If it needs to, the task was mis-sized — return to parent.
• log() anything dropped (top-N caps, no-retry, sampling). A silent cap reads as "covered everything."

Cut fan-out cost at the source

• Share a compressed brief, not the full conversation. Naive fan-out triples input cost; a shared compressed brief lands net spend at ~1.6-1.8× instead of 3× (velsof 2026). On gotcontext, profile=core uses ingest_context → read_skeleton; gc_pre_flight is the profile=full/Pro+ route.
• Force structured returns (schema/typed envelope: claim + evidence + file:line + confidence), not free text — cheaper to synthesize, and a 0-confirmed result is legible as failure vs. success.

When NOT to fan out at all

A single well-tooled agent ships faster, runs cheaper, and is easier to debug for narrow tasks. Fan out only when work genuinely parallelizes (independent probes, multi-source retrieval, cross-doc synthesis) or needs genuine specialization. "Feels thorough" is not a reason — it's a 15× bill for nothing.

Red flags — STOP, you're about to overspend

• About to call agent() / Agent with no model: → you're inheriting the default.
• Firing a Workflow without a stated tier split → the operator can't see the spend shape.
• Reaching for opus/fable on discovery, grep, inventory, or routine verify → tier down.
• "Just use the strong model everywhere to be safe" → that's the exact 5.6M-token failure.
• A verify wave returned 0 confirmed from a large fan-out → treat as RATE-LIMITED/UNVERIFIED, not clean; re-run the top findings yourself.
• Parallel agents that WRITE files without isolation: 'worktree' → they clobber the tree.

Rationalization table

Excuse	Reality
"Inheriting the default is fine"	The default is the caller's tier — usually too expensive for rote work. Set model: every time.
"Opus/Fable gives better results everywhere"	Only on hard reasoning. On grep/extraction/routine-verify it's identical output at 3-10× cost.
"Stating the tier split is bureaucracy"	It's the one artifact that makes spend visible before it burns. 30 seconds.
"Bigger fan-out = more thorough"	Beyond genuine parallelism it's linear cost for zero quality — and trips rate limits.
"0 confirmed means the code is clean"	From a rate-limited fan-out it means the agents never reached the API. Verify.

Real-world impact

Two gotcontext workflows ran ~5.6M subagent tokens all on inherited Fable (2026-06-19). Tiered (haiku/sonnet bulk + 3-4 opus/fable synthesis) the same shapes were ~60-70% cheaper for the same output. Fable currently unavailable except via cursor at excessive cost → default to opus for the top seat and say so.

Cross-references

• superpowers:dispatching-parallel-agents — the Workflow tool mechanics; set model: per agent() phase there
• A peer-review council, if this project runs one — council seats already run on their own subscriptions; tier the CHAIRMAN synthesis
• An act-vs-ask common-sense-gate discipline, if this project has one — reversible/within-budget → act; this skill governs the model tier once you act
• codebase-audit — the read-only token-discipline audit shape this pairs with