Subagents in AI Coding Agents: Isolate Search From Reasoning

You ask the agent one question: where does this app validate a webhook signature, and which routes skip it? Ninety seconds later it has the answer: middleware/webhook.ts:42 validates, and two routes, /admin/import and /internal/replay, bypass it. Correct, and useful. Above that one sentence, though, the transcript is four greps, five file reads, and ten reasoning turns weighing which lead to follow next - and every one of those happened on the same model, in the same window, that’s about to design the fix.

Two pieces on this site have already gone after the mess a search leaves behind. One skips the search entirely, for the case where you already know which files matter. Another writes the search down once, so a later run on the same slice doesn’t pay for it twice. Both assume the search happens somewhere reasonable and just try to avoid repeating it. Neither asks where “somewhere” actually is. Say you don’t know the files yet, and you won’t be back on this exact question again - priming and caching don’t apply. You still have to look. The only open question is which model does the looking, and in which window.

That’s the tension underneath all of it: finding the one fact a plan depends on takes reading broadly, and reading broadly, in the same window on the same model you’re about to reason in, is at once the most attention-degrading way to think and the most overpriced way to pay for it.

Move the search to a subagent pinned to a cheap model instead, and you get two separate wins from one move, not one win counted twice. On Anthropic’s own current list prices, Claude Opus 5 at $5 per million input tokens against Claude Haiku 4.5 at $1 per million, the search itself costs exactly a fifth as much. And because the parent session only ever reads what the subagent hands back, its own window receives 100 times fewer tokens of the search than it would have if it read the files itself. Stick with these two models for the whole piece: swap in your own reasoning model and the price ratio moves, more on that near the end.

Thirty seconds settles it, no arithmetic required yet.

Open a fresh session on a real repo and ask a find-it question you already know the answer to: where does this happen, which callers exist, why does this config touch three packages. Before it answers, scroll back and look at what piled up on the way there - greps, file reads, directory listings - and ask where they landed. Did that search happen in the same window you’re about to ask the model to reason in, or in a subagent’s own window that only handed back a short answer?

If your setup already routes search to a subagent, and that subagent is already pinned to something cheaper than your main model, you’re already doing the thing this piece is about. Close the tab.

If the search happened inline, on the same model that’s about to plan the fix, keep reading. That’s the setup priced out below, exactly.

Fix the particulars once and reuse them everywhere below, the way the site’s other pieces on this villain do.

The question: where does this app validate a webhook signature, and which routes skip it. The reasoning model: Claude Opus 5, $5 per million input tokens, $25 per million output. The cheap explorer: Claude Haiku 4.5, $1 per million input tokens, $5 per million output, both quoted from Anthropic’s own pricing page. The budget: a 200,000-token context window, the same figure cache-the-explore used, because it’s the size most agent CLIs ship with today. The ground truth, established once and reused everywhere below: middleware/webhook.ts:42 validates; /admin/import and /internal/replay don’t.

Watch an agent get there and count what it does:

Add the three subtotals - that’s the whole computation, done the obvious way, before anything clever happens. 12,000 tokens, before the agent has said one word about the fix.

What comes back to whoever asked the question doesn’t need to be 12,000 tokens. It’s a file path, a line number, two route names, one sentence - 120 tokens, kept deliberately short. Call that short answer the distillate: what’s left once everything the search didn’t need is gone. Hold onto that number; it’s the entire payoff, and it shows up again in every section below.

Now the number worth planting. At Opus 5’s own price, that 12,000-token search costs $0.06 to read inline, in the same window that’s about to reason about the fix. Remember $0.06.

Route the same 12,000 tokens through a subagent pinned to Haiku 4.5 instead, and the parent session never reads them at all. It reads whatever the subagent hands back.

Price first. Haiku 4.5’s input price is a fifth of Opus 5’s, so the same 12,000 tokens of search, read by the cheap model instead of the expensive one, cost $0.012. Divide $0.06 by $0.012 and you get exactly 5 - not a coincidence, it’s Opus 5 and Haiku 4.5’s own input-price ratio, 5 to 1, showing up untouched in the search bill. The plant pays off: $0.06 against $0.012, five to one.

Window footprint is a separate axis, and it pays off independently. The parent’s own window never holds the search at all, only the 120-token distillate that comes back. Twelve thousand divided by 120 is 100. On a 200,000-token window, that search would have eaten 6.00% of everything the model will ever hold if read inline, and 0.06% if delegated. Remember 100x. It isn’t derived from the 5x above - one number is what you paid, the other is what you’re carrying.

Both numbers fall out of one move: hand the search to a subagent, pin it to a model a fifth the price, and let only the distillate cross back into the parent. Call that move the cheap reader. It isn’t two techniques stapled together. Isolating the search from the reasoning window and arbitraging its price are the same move, paying out twice.

parent window (Opus 5, about to design the fix)
  Task: "find where webhook signatures are validated,
         list every route that skips it"
       explorer subagent (Haiku 4.5, pinned in its own window)
         grep, read, grep, read, read...          12,000 tokens, spent here
       returns: "middleware/webhook.ts:42 validates;
                 /admin/import and /internal/replay don't."   120 tokens, all the parent ever sees

Nothing about the parent’s window changed shape. It’s exactly as clean after the search as it was before, and 120 tokens lighter than it would have been carrying the search itself.

Before that 5x goes to your head: $0.012 is only what the search itself costs on the cheap model. Delegating isn’t free - something has to write the 120-token distillate, and the parent has to read it.

Add both. Haiku writing 120 tokens out costs $0.0006. Opus reading those same 120 tokens in costs another $0.0006, because it’s Opus’s input price, not Haiku’s, that the parent pays to read anything, including a summary. The full round trip: $0.012 plus $0.0006 plus $0.0006, which is $0.0132.

$0.06 against $0.0132 is still a real saving, $0.0468, but the ratio it comes out to is 4.55x, not the clean 5x the plant promised. The 5x is the search-phase price ratio only. The number that survives the whole round trip is 4.55x. Cheaper, not free, and the gap between those two claims is the honest one to make out loud.

Every number so far comes from one pair of formulas, run at different sizes. Read inline: search tokens times Opus 5’s input price. Delegated: search tokens times Haiku 4.5’s input price, plus the distillate written out at Haiku’s output price, plus that same distillate read in at Opus’s input price. Run both across four scenarios and the shape holds every time:

Row 1 is the trap in the other direction. A real saving, $0.0028, on a lookup small enough that the round trip to a second model probably costs more in latency than it saves in tokens. More on that below.

Row 2 is the toy walked through above, sitting next to its neighbors for the first time.

Row 3 scales the same shape up: why does the production build pull in two versions of the same date library? There’s no single answer location for that question. It takes reading lockfiles, walking the dependency tree, opening several package.json files across a monorepo, maybe a grep for the offending import - a guaranteed several thousand tokens of tree output for a diagnosis that still comes out to one sentence: pkg/api pins one major version, pkg/web floats another, and the bundler can’t dedupe across them. More search, a same-sized finding at the end of it. The ratio actually improves, to 4.85x, because the fixed cost of the round trip, the 120-token write-and-read, matters less the more search it’s amortized against.

Row 4 is three parallel explorers, each doing webhook-sized work, each handing back its own 120-token distillate. Thirty-six thousand search tokens is 18% of a 200,000-token window if it all landed inline at once, in the same session. Delegated, it’s 0.18%. Fan out three explorers in the open, in your own window, and you’re closing in on a fifth of everything the model will ever hold, before it has reasoned about anything at all.

Every row runs the same two formulas. What changes is how much search you’re paying for, not the shape of the trade.

None of this happens automatically. Claude Code’s subagent model field defaults to sonnet, not to whatever’s cheapest, so a reader who already runs subagents needs to say the cheap routing out loud:

---
name: explorer
description: Read-only codebase investigation. Returns findings only.
model: haiku          # pinned explicitly - the default is sonnet, not this
tools: Read, Grep, Glob
---
You are a read-only explorer. Search the codebase to answer the question.
Return ONLY: exact file paths, line numbers, and a short summary. Do not
paste large file contents back to the parent.

Two lines are doing the real work. model: haiku is the price cut - leave it unset and you inherit the parent’s model, and the whole 5x is gone before it started. And “exact file paths, line numbers” in the prompt is what keeps the 120-token distillate checkable at all, which the next section leans on. The tool list has no write access either, which is what makes handing this off safe by construction - see permissions for why read-only-by-default is the right posture for delegated search.

It’s worth being precise about why a cheap model tolerates this job at all, instead of just asserting it. Grepping for a string, checking which function calls another, working out which file owns a config - that’s breadth-first, low-ceiling work: does the pattern match, yes or no. Deciding what the fix should be holds several constraints against each other at once, where a small accuracy gap changes whether the fix is right. The model split is the search finally getting a model sized to what it actually asks of one, not a cost hack bolted onto subagents after the fact.

Row 1 in the table above is the honest case against this whole move. $0.0028 saved on a lookup that small is real, but spinning up a subagent, waiting on it, and reading its answer back probably costs more in latency than the three-tenths of a cent it saves. If the question is small enough that the search is the answer, do it inline. Cache-the-explore made the same call about its own mechanism: the ratio looks great, the absolute stakes don’t.

And if you’re about to hand-edit the exact files the search would have found, reading them yourself was never overhead. It was the next step, just arriving a little early.

Delegating the search doesn’t just keep it out of the parent’s window. It keeps it out of your view too. The 120-token distillate is now the parent’s only picture of what actually happened during that search, and it isn’t auditable the way a polluted window still is - somewhere in a messy transcript, the truth is at least present. A confident three-sentence summary that quietly missed the one edge case that breaks the plan is a sharper failure than that, because there’s nothing left to catch it against.

One guard survives: make the explorer return exact file paths and line numbers, not just prose, so the parent can pull the three lines that actually matter back into its own clean window if the plan hinges on them. That’s a spot-check, not an audit. It lets you verify the claim you already suspect. It does nothing for the one you don’t know to doubt yet.

Is the cheap model even good enough to trust with this? NVIDIA’s own position paper on small models for agentic work, “Small Language Models are the Future of Agentic AI” (arXiv:2506.02153, 2025), argues narrow read-many tasks like this one are exactly where a small model belongs, and that it already runs 10 to 30 times cheaper than a frontier model doing the same job. The same paper concedes real adoption barriers though: tooling, trust, and the habit of reaching for the strongest model everywhere by default. Treat “good enough” as a claim to verify on your own codebase - unusual patterns, unfamiliar frameworks, dense legacy code are exactly where a cheap model’s pattern-matching gets worse - not a guarantee this piece can hand you.

None of this replaces the site’s other two pieces on the same villain; it sits between them. Priming is for when you already know the files - skip the search entirely. The disposable map is for when you’ll run the same search again - write it down once instead of delegating it again. The cheap reader is for the run where you don’t know yet and won’t be back: you still have to look, you just don’t have to look in the window where you’re about to think, or on the model that’s about to do that thinking.

The obvious alternative, a repo index built from embeddings, doesn’t answer this either. Cache-the-explore already made that case in full: a better index makes each search sharper, it still has the agent doing all the reads. Search quality and where the reading happens are different questions. This piece is only about the second one.

Worth naming while it’s fresh: the reason attention degrades on a stuffed window isn’t a hunch. Chroma Research’s “Context Rot” (Kelly Hong, Anton Troynikov, and Jeff Huber, July 2025) tested eighteen frontier models and found accuracy drops as input grows, well before any of them hit their documented context limit. That’s the fact underneath everything above the pricing table: keeping the search out of the window isn’t only about the bill, it’s about what the model can actually attend to once the bill is paid.

Isolating the search from the parent’s window bought two things you can price exactly: a fifth of the cost, on Opus 5 against Haiku 4.5’s own list prices, and a hundredth of the footprint, 120 tokens against 12,000, in the window where the model is about to think. Both numbers describe what you paid. Neither one describes what you can now check.

That’s the open question this piece hands forward, and there’s no next piece on this site that answers it yet. Quarantining the search from the reasoning window also quarantines it from the reader’s ability to audit it. The parent trusts a 120-token summary it never saw the evidence behind, produced by a model it didn’t use to verify anything itself. Exact file paths and line numbers are a guard against that, not a fix for it - they let you check the one claim you already doubted. They do nothing for the one you didn’t know to doubt. The cheap reader saves five to one on price and a hundred to one on window space. What it costs is legibility, and this piece never priced that part.

About the numbers. The search-phase counts (4 greps, 5 file reads, 10 reasoning turns, and their per-call token sizes) and the 120-token distillate are toy numbers, authored for hand-tracing rather than measured off a real transcript, sized to the same order of magnitude as cache-the-explore’s own 22,800-token example, scaled to a narrower question. Every dollar figure and ratio in this piece, the $0.06 plant, the $0.012 and $0.0132 payoffs, the 5x and the 100x, and all four rows of the master table, is arithmetic that follows from those toy numbers and the two prices below, re-checked against a script before publishing. Claude Opus 5’s list price ($5 per million input tokens, $25 output) and Claude Haiku 4.5’s ($1 per million input tokens, $5 output) are quoted from Anthropic’s own pricing page, fetched August 16, 2026, and will drift. Swap in your own reasoning model’s price and the 5x moves with it: a reasoning model priced at $2 per million against the same Haiku 4.5 only clears a 2x price ratio, but the mechanism, isolate the search and let a cheaper model read it, doesn’t change, only the multiplier does. The 200,000-token window is the same convention cache-the-explore used, not a measured limit of any specific model.

For the per-tool mechanics, see Subagents for running the explorer in its own window, Model selection for pinning it to a cheaper model, and Permissions for keeping a read-only explorer safe by default.