You need a dependency graph read out of a large module, and your very next instruction is going to act on what comes back. You can dispatch the worker so that it blocks the conversation, or so that it runs alongside you. Which account of the two options is right about what each costs you here?

The principle — a delegation is priced against the turn its answer is needed in, and the wait for a fresh worker is a separate cost that neither mode avoids.

Why the key is correct — the requirement in the stem is that the next instruction depends on the finding, and only one mode can meet it. Foreground subagents block the main conversation until complete, so the answer exists in the same turn that asked for it; a background subagent's results reach Claude as a completion notification in a later turn, which is one turn too late here. That settles the choice. The second half of the key is the part the choice does not buy: latency matters, and a subagent starts fresh and may need time to gather context. A fresh worker has to read its way in before it can answer, whichever way it was dispatched.

Why the others are wrong — the first treats non-blocking as free, and it is not: the price is the delivery turn, plus the same start-up the other mode pays. The second collapses the two modes into a question of what you may type while waiting, which misses that one of them cannot answer this turn at all. The last picks the right mode for the wrong reason, and the reason matters: choosing to wait does not make a fresh worker gather its context any faster, so anyone expecting an instant answer will be surprised by the pause and start looking for a fault that is not there.

Remember this — ask which turn you need the answer in first; that decides the mode. Then expect the start-up either way.

Sources — Anthropic's Claude Code subagents documentation.