Delegation vs. the 5-hour window
Three ways to spend an Opus session on the same task — a hand-built baseline, Scott Caffery's smart-meter skill, and superpowers subagent-driven development (SDD) — measured by the only budget that actually binds a subscription user: your rolling 5-hour usage limit.
Every subagent runs on your account, so the question isn't "is delegation clever?" — it's how much of your 5-hour window each approach burns to deliver the same result. Usage limits are consumed faster by pricier models, so a model-weighted token cost is a direct proxy for "share of the window used." That proxy is the currency of this report.
- Cheapest per task = one agent on the cheapest capable model, no review. That maximises how much you get done before the cap.
- smart-meter only beats the baseline once you drop its review ($1.22 vs $1.54); with the review it's 1.7× the burn. Its real value is the safety read-out before irreversible actions and offloading genuinely large grind.
- SDD costs ~12× the window (~34 min) and buys verified correctness — it caught 2 real bugs here — not throughput. Use it when a shipped defect is expensive.
- Biggest lever on your 5-hour window: main-loop model choice and agent count. Every subagent is a cold-start charge — don't run Opus for what Sonnet or Haiku can do.
The three contenders
Baseline
One agent does the whole task on the main-loop model. No review step. The control.
smart-meter
Keeps the expensive main loop as your lever, hands the "grind" down to a pinned cheaper-model subagent, and reserves the top tier for a review before shipping. Ends each turn with a confidence read-out.
SDD
A controller executes a plan: a fresh implementer per task, a task-reviewer after each, fix loops on findings, then a whole-branch final review — models chosen per role.
Method
Each approach was run as a background agent tree; token usage and model were read per message from the agent transcripts and priced at current rates (a proxy for window-burn), then summed across the whole tree — orchestrators and every subagent they spawn.
- Prices per 1M tokens (in / out / cache-write / cache-read): Opus 4.8 $5 / $25 / $6.25 / $0.50 · Sonnet 5 (intro) $2 / $10 / $2.50 / $0.20 · Haiku 4.5 $1 / $5 / $1.25 / $0.10.
- "No review" column = the same run with the review machinery removed: for smart-meter, the Sonnet worker alone (drop the Opus review pass); for SDD, controller + implementers only (drop the 5 task-reviewers, 2 fixers and final Opus review).
- Caveat: each fresh subagent pays a cold-start cache-write of the agent system prompt, so absolute multipliers are inflated versus a single warm session — but that cold-start is a real per-subagent charge against your window, so the ranking holds and "more agents = more burn" is the honest lesson.
Run 1 — Sonnet loop, a summarize "grind"
Read 10 documents, summarize each and extract themes — exactly the bulk/mechanical work smart-meter is built to offload. Main loop on Sonnet; smart-meter delegated the reading to a Haiku grind subagent.
| Approach | Tokens | Window burn | vs baseline | Latency |
|---|---|---|---|---|
| Baseline — Sonnet solo | 839,767 | $0.537 | 1.00× | 22s |
| smart-meter — Sonnet → Haiku grind | 903,080 | $0.535 | 1.00× | 34s |
Verdict: a dead heat (0.5% cheaper) — and smart-meter used more total tokens and 55% more wall-clock. The grind genuinely ran cheaper on Haiku, but spinning up a second agent cost about what it saved. No review step in this run.
Runs 2 & 3 — Opus loop, a coding task
Build a self-contained fitness dashboard (single index.html, hand-rolled SVG charts). Main loop on Opus. This is where an expensive main model should make delegation pay — and where SDD joins as the third contender.
| Approach | Agents | Full — tokens | Full — burn | No-review — tokens | No-review — burn | Latency | Verified? |
|---|---|---|---|---|---|---|---|
| Baseline — Opus solo | 1 | 417,196 | $1.54 | n/a | $1.54 | 108s | no (shipped unreviewed) |
| smart-meter — Opus → Sonnet + Opus review | 3 | 3,259,902 | $2.66 | 2,560,569 | $1.22 | 292s | yes — found nothing |
| SDD — controller + 3 impl + 5 review + 2 fix + final | 12 | 26,014,707 | $18.05 | 18,251,654 | $12.27 | 33.5 min | yes — caught 2 real bugs |
Where SDD's burn actually goes
| Role | Model | Tokens | Burn | % of run |
|---|---|---|---|---|
| Controller (coordination only) | Opus | 5,963,568 | $8.05 | 45% |
| Implementers ×3 | Sonnet | 12,288,086 | $4.22 | 23% |
| Task-reviewers ×5 | Sonnet | 3,644,069 | $2.80 | 16% |
| Fixers ×2 | Sonnet | 3,804,806 | $1.52 | 8% |
| Final review ×1 | Opus | 314,178 | $1.45 | 8% |
The biggest single cost isn't implementation or review — it's the Opus controller accumulating a 5.2M-token context over 68 turns reading briefs, reports and diffs. The methodology's orchestration is the burn, and it sits on your most expensive model.
The "no review" question
The asymmetry that matters: the baseline and smart-meter dashboards look perfect — but they shipped unreviewed, so we can't actually prove they're bug-free. SDD is the only one we know is verified. Its 11.7× burn didn't buy a 12×-better dashboard; it bought proof of correctness.
The end products
All three built the same "PulseTrack" dashboard — four stat cards plus hand-rolled SVG charts, fully self-contained. Judge for yourself; they're peers.
Which workflow, when
Baseline — single agent
Reach for it for most work: reversible, low-stakes, or anything you'll eyeball yourself. Cheapest per task and the fewest cold-starts against your window.
Skip when: output ships unseen and a bug would be costly — it has no verification.
smart-meter
Best when the main loop must stay on an expensive model but the task has a large mechanical chunk to hand to a cheaper tier — and when you want an automatic confidence / blast-radius check before an irreversible action (send, delete, deploy). Consider dropping its review for low-stakes work.
Skip when: the task is small (overhead ≈ savings) or already low-stakes and reversible.
SDD
Best when correctness outranks cost: production or irreversible code, a multi-task plan, or work that ships without a human read. Buys TDD per task, spec + quality gates, and real bug-catching.
Skip when: the task is quick, throwaway, exploratory, or you'll review it yourself — it's ~12× the window.
Takeaways — maximising the 5-hour window
- Model choice and agent count are the real levers, not clever delegation. Every subagent is a cold-start that re-caches the system prompt against your window. SDD's 12 agents = 12 cold starts. Delegating from Opus keeps an expensive loop resident and adds those starts — on routine work it costs window, not saves it.
- For reversible, low-stakes work: cheapest single agent, skip the review. That maximises throughput. smart-meter-with-review and SDD are both net-negative for your window on a task like this.
- Match ceremony to stakes. The verification you're buying only pays off when a shipped defect actually hurts — irreversible actions, production, or code you won't eyeball. That's the narrow band smart-meter reserves its review for, and where SDD's machinery earns its (very large) keep.
- Delegation's saving is smaller than the sticker gap. Cheaper models take more turns; a Sonnet worker used ~6× the tokens Opus needed for the same dashboard, so its 2.5×-cheaper rate netted only ~20% off the doing — before any orchestration or review overhead.