delegate

name	delegate
description	Push heavy work into sub-agents and keep the main conversation's context clean. Use when starting any multi-step task — codebase research, sprint execution, browser/Playwright verification, or anything that would otherwise dump large output (screenshots, file listings, wide search results) into the main loop. Bring back only the conclusion.
license	Complete terms in LICENSE

Delegate — keep the main loop clean

The main conversation loop is the scarce resource. Every screenshot, file dump, long search result, and verbose tool output that lands in it costs context, slows every subsequent turn, and degrades reasoning quality. The fix is simple and nearly always correct: do the heavy work in sub-agents and bring back only the conclusion.

The rule

When a task is more than a couple of steps, or would pull large output into context, delegate it to a sub-agent. The main loop should orchestrate and decide — not be the place where 30 screenshots, a 2000-line file, or a wide grep dump accumulate.

When to delegate (default yes)

• Codebase research / exploration — "where is X", "how does Y work", sweeping many files. Use a read-only exploration agent and get back a tight summary with file:line pointers, not the file contents.
• Browser / Playwright verification — this is the big one. Screenshots are the fastest way to blow up context. A sub-agent should drive the browser, take the screenshots, and report back "all flows pass, here are the 3 that matter" plus the saved paths. Keep the image payloads out of the main loop.
• Sprint / task execution — each chunk of an implementation plan runs in its own sub-agent with the relevant plan section and file paths.
• Anything fan-out-able — independent chunks of work run as parallel sub-agents in a single message. Parallel is great but not required; serial sub-agents still keep the main context clean.

Run them in parallel

When delegated tasks are independent, launch them in parallel — issue multiple agent calls in a single message and they run concurrently. This is the default for independent work (research multiple subsystems, verify multiple flows, execute independent sprints): it's faster and keeps the main loop just as clean as serial. Only go serial when one sub-agent's output feeds the next. When in doubt and the tasks don't depend on each other, fan out.

Forcing yourself to name what can run in parallel is half the value of this skill — it makes you decompose the work into independent units instead of one long serial slog.

Reasoning effort

If a delegated task is genuinely hard and needs strong reasoning, give that sub-agent a stronger model / higher reasoning effort rather than pulling the work back into the main loop to "do it carefully here." The point is to keep the main loop clean and fast — strong reasoning belongs in the sub-agent doing the hard part.

What stays in the main loop

• Orchestration: deciding what to delegate, in what order.
• The user-facing narrative and decisions.
• Small, cheap reads where spinning up an agent costs more than it saves (one known file, one config value). Don't delegate a single cat.

The smell test

Before running a wide search, a browser flow, or reading a big file directly in the main loop, ask: will this output be large, and do I only need the conclusion? If yes — delegate it. When in doubt, delegate.

For concrete before/after delegation patterns, see EXAMPLES.md.