ruban.sh
Back

Post · 17 November 2026

What happens in the subagent stays in the subagent

Send the reading to subagents on cheaper models so your main agent only sees what they found.

I think the main reason to use subagents is to keep your main agent’s context clean. Reading logs, going through files and looking for patterns in a codebase all produce a lot of raw output. If the main agent does that work itself, every line of it lands in its context window and stays there for the rest of the session. If a subagent does it, the main agent only sees what came back.

Most agents won’t do this reliably on their own. Claude Code has a built-in Explore agent, but it doesn’t always trigger when it should, and when Claude does launch a subagent it usually gives it the same model as the parent unless you say otherwise. So it’s worth putting in your AGENTS.md or your agent’s memory.

A recent example: I was building a tool and wanted to compare a few open source projects that each had part of what I needed, but none had all of it. My agent explored four or five repos in parallel, one subagent each, and came back with a single design that combined the parts I needed from all of them. If one agent had gone through them one after another, by the fifth repo it might have lost track of what it found in the first, and that’s when it starts making things up.

The tradeoff is cost against speed. Subagents usually cost more in total, because each one reads its material from scratch. In return you get speed from running them in parallel, and you save money in a less obvious place. Your most expensive model is usually your main agent, and the subagents run on cheaper ones, so the expensive model never reads or writes all that raw data. It only reads the results.

This doesn’t have to stop at one layer either. I use Fable as my main agent. Sometimes Fable plans the work and hands it to Opus to carry out. Other times it goes further, with Fable handing work to Opus and Opus handing the narrower pieces to Sonnet or something smaller, and the results come back up the same chain. Each layer only passes up what the one above it needs. Low effort is usually enough for something like a log finder, and medium effort works well for Opus. The idea is to match how much intelligence you spend to how hard the work is.

Cascading subagentsThe main agent, Fable or Opus, sends a brief to an optional orchestrator on a cheaper model, which sends briefs to four cheaper subagents reading logs, two repos and files. Findings come back up each layer, and the raw output stays with the subagents.Main agentFable or OpusPlans and reads findingsOptionalOrchestratorA cheaper modelMedium effortBriefFindingsBriefFindingsRaw output stays down hereLogsHaiku, low effortRepo ASonnetRepo BSonnetFilesHaiku, low effort
Each layer sends a brief down and passes only its findings up. The models get cheaper further down, and most setups skip the middle layer.

A subagent only knows what’s in its prompt, so the brief needs the goal, what’s already been ruled out and when to stop. What it sends back needs the same care. Ask for findings with file paths and line numbers. If a subagent returns a dump of raw output, the mess has just moved up a layer.

Delegating isn’t always worth it. If you already know which file you need, reading it directly is quicker than writing a brief. And a subagent’s report sounds just as confident when it’s wrong, so check what comes back before acting on it, the same way I wrote about in Trust the tests, not the vibes.

You can put this in your AGENTS.md, or tell your main agent directly. Replace [MODEL] with the model you want the subagents to use:

When a task would fill your context with raw output, such as reading logs, searching files, exploring repos or comparing projects, launch a subagent for it using [MODEL] instead of doing it yourself. Use low effort for simple searches. Give each subagent the goal, what’s already known and when to stop, and run independent tasks in parallel. Have each one return its findings with file paths and line references, and check those findings before you act on them.

I wrote about the browser version of this in You hired a genius to click Next. The same idea works for anything that’s mostly reading.