# Cost Tiered Orchestration

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

- Skill: `oimiragieo/cost-tiered-orchestration` (Agent Skill)
- Install (CLI): `npx skillmds@latest add oimiragieo/cost-tiered-orchestration`
- Raw SKILL.md: https://api.skillmd.com/api/skills/oimiragieo/cost-tiered-orchestration/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: oimiragieo (https://skillmd.com/u/oimiragieo)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/oimiragieo/cost-tiered-orchestration

---


# 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](https://www.ayautomate.com/blog/what-is-llm-orchestration)). 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](https://smartmobilehouse.com/blog/multi-agent-systems/)).

## 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](https://www.velsof.com/ai-agents/multi-agent-ai-orchestration-patterns/)). 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