Don't pay the expensive model to read logs

A repo search across five projects, a batch of the same one-line edit repeated forty times, a test run that dumped six thousand lines of stack traces I need boiled down to the three that matter. None of that needs the expensive model. All of it will happily eat the expensive model’s budget if you let it run inline.

So I don’t. The orchestrator, Sonnet or Opus or Fable, whichever is doing the thinking that session, keeps the parts that need judgment: breaking a task into independent slices, deciding the architecture, reading two subagents that disagree and figuring out which one is right, the final pass before anything ships. Everything token-heavy and mechanical goes to cheaper subagents running in parallel: search the codebase for every caller of a function, extract the API shape from a doc, reduce a wall of test output to the failures, do the repetitive edit across forty files, drive a browser through a test pass.

The handoff has to stand on its own

A subagent has never seen the conversation. If the prompt reads like a note to myself, it fails quietly and I don’t find out until later. So the prompt carries everything: the repo path, the objective, what’s in scope and what isn’t, the exact form I want the answer in (file paths, line numbers, commands run, diffs, what failed, where it wasn’t sure), and the commands it should run to check its own work. I also give it stop conditions: if the code doesn’t match what the prompt assumed, if a command fails twice, if it needs a file outside what I scoped, stop and tell me instead of guessing forward.

Independent slices go out together, in parallel. Whatever’s coupled, the piece that blocks my very next step, stays local. Splitting that off just adds a round trip for something I need in five minutes anyway.

Reports are leads, not facts

A subagent’s summary describes what it meant to do, not necessarily what happened. Before I take a claim, I reopen the files it cited and check the line numbers are real. Before I trust a fix, I read the actual diff. It’s not distrust of the model so much as the discipline I’d want from a human report: show your work, and I’ll still check it before I sign off. The subagents make the cheap work fast. The rule about not trusting them is what keeps fast from turning into wrong.

Worth saying plainly: the multiplier isn’t fixed. On codebase-heavy work with slices that don’t depend on each other, I’ve seen roughly three to five times cheaper and two to four times faster than doing it all inline. On a task that’s one tight, sequential thread, none of that holds, and I just do it myself. The saving comes from the shape of the task, not from delegating on principle, and the shape is the same whichever frontier model sits in the orchestrator seat.