Sub-agents

Inside a single turn, Perch can hand a piece of work to a sub-agent: a helper with a narrow objective, its own context, and a limited set of tools. The helper does the work and returns a conclusion. Perch keeps the thread, makes the decisions, and writes the answer.

This is the primitive underneath the bigger modes. One sub-agent is a helper. A planned team of them, running in phases and checking each other, is Flock.

Why hand work off at all

The obvious reason is speed, and it is the least important one. The real reason is context.

Reading forty invoices takes forty tool results. If Perch reads them itself, all forty land in the conversation and crowd out everything else, including your original question. If a sub-agent reads them, only its findings come back. The raw material stays in the helper's context and the main thread stays clear enough to reason about what was found.

Two other reasons matter:

• Independent judgment. A checker that reviews a draft against its sources has not spent the last ten minutes writing that draft. It is easier to catch a missing citation when you are not the one who wrote around it.
• Real parallelism. Twelve vendors, twelve independent questions, no cross-talk between them. Those run at the same time rather than one after another.

When Perch reaches for one

The test Perch applies is simple: is this piece self-contained, and do I only need its conclusion? Both yes means hand it off. Either no means stay in the loop.

In practice that means:

• Gathering evidence across many files. Sweeping a folder, pulling figures out of a stack of statements, mapping a large codebase.
• Exact computation. Reconciliation and totals, run as real analysis in the sandbox rather than estimated in prose.
• Checking finished work. Re-reading a draft against the sources it cites and reporting what does not hold up.
• Independent chunks. The same question asked of many separate things.

And it deliberately does not hand off:

• Anything conversational. A sub-agent cannot see your conversation and cannot ask you a question. If the work needs either, it stays in the main loop.
• Small work. A single file read or a quick edit costs more to hand off than to do.
• Delivery and real-world actions. Sending an email, creating a document, booking a calendar event. Perch drafted it, so Perch delivers it, with every prior step still in mind.

Choosing the model they run on

On Perch Desktop, the model menu in the composer has a Sub-agents row: Agents run on. Leave it on Inherit and helpers run on whatever the turn is running on. Pick a model and every helper Perch spawns runs on that one, including background delegates.

The models offered are the same ones you can pin for yourself, so what your plan includes for pinning it includes here. An agent on a named model bills like any other pinned model; Inherit stays on Roost routing.

Perch can also choose per helper within a single task when there is a reason to, which makes one pattern worth knowing: have a different model check the work. A draft reviewed by the model that wrote it tends to agree with itself. Reviewed by another, disagreements surface. Ask for it directly:

draft the summary, then have a different model verify it against the sources

If you name a model that your plan does not include, Perch says so and stops rather than quietly using a different one.

The effort bar decides how willing it is

The effort bar on the composer sets how much Perch invests in a turn, and that includes how readily it fans out.

Work that outlives the turn

A sub-agent runs inside the turn you are waiting on. When the job is long enough that you would rather not wait, /delegate hands it to a background agent instead, gives you the prompt back, and brings the result to you for review when it is done. See Slash commands.

Limits

• No recursion. A sub-agent cannot spawn its own sub-agents. Orchestration tools are removed from every helper.
• Bounded runs. Each helper has a cap on how many steps and tool calls it can take, enforced by Perch rather than requested from the model.
• Honest results. A helper that could not read a file reports it as unread. A partial result comes back as partial.
• Perch Terminal only. Sub-agents need the local file access that the desktop app and CLI have. Web chat answers in a single pass.

For the loop they run inside, see The operator and agents. For how a whole team is planned and verified, see Flock.