Fan Out: Coordinating Dozens of Agents in Parallel Without Blocking

Fan Out: Coordinating Dozens of Agents in Parallel Without Blocking

Transcript

A lightly formatted transcript of the video, with timestamps so you can jump to any section on YouTube.

[0:00] One agent can't analyze 50 SEC filings in parallel, but dispatch them separately and have the main agent wait for all three to finish at once. This is Liam in for Bear. The question, how does a single agent coordinate long-running parallel sub-agents without resorting to multiple separate conversations or blocking the whole flow? A custom tool becomes the orchestration trigger. When the head agent calls dispatch {underscore} analysts with a list of tickers, the server intercepts that call. It doesn't run the analysis itself. It spawns three analyst sessions, each with its own full context window, each running in parallel. The head agent pauses. The server monitors the sessions. When all three finish, the

[0:39] Server resumes the head with the accumulated results. Fan out, fan in. Here is the flow. Head of research receives the prompt. Sweep NVDA, AMD, and MU ranked by margin durability. It calls dispatch analysts with the three tickers. The server intercepts. Three analyst sessions spawn simultaneously. Each reads 20 pages of SEC filings independently, scores on a rubric, returns a grade. The head waits. It doesn't block your terminal. It doesn't lock the conversation. The server monitors all three in the background. When all three finish, NVDA scores nine, AMD scores six, MU scores four. The head resumes, reads the accumulated table, synthesizes a ranked report. One conversation, three parallel analysts,

[1:18] One merged verdict. The spread is the mechanism. One call fans out into N parallel sessions. Each session is fully isolated, its own context, its own tools, its own errors. They converge when they finish, not when the head decides to check. The server is the coordinator, not the agent. The timing difference is not incremental, it is categorical. Serial execution, 50 analysts each taking 30 seconds one after another. That is 25 minutes. You are not waiting for the analysis, you are waiting for the queue. Parallel fan out, 50 analysts dispatched simultaneously. They all start at the same moment. All 50 finish in 30 seconds. The timeline collapses from 25

[1:54] Minutes to the duration of the slowest single analyst. Serial is a queue, parallel is a wave, the wave does not wait. When the analysts finish, their results don't merge themselves. The aggregator box is the other half of the fan out pattern, the fan in. Each analyst session returns its result as a chip ticker score findings. The chips arrive at different times. The aggregator holds them until the last one lands, then it runs three operations to duplicate, remove any overlapping findings, rank sort by score, merge, flatten everything into one structured report. The head agent reads that report and synthesizes the verdict. The aggregator is not smart, it is just a collector that waits

[2:30] For the full set before it hands anything back. What makes parallel agents safe is not clever engineering, it is a contract. The head sends a fixed schema, task ID, company ticker, query focus. The analyst returns a fixed schema, task ID, findings array, confidence score, sources. The contract in the center defines both sides. That standard schema is what the aggregator relies on. If an analyst returns something off schema, the aggregator rejects it cleanly. One failed session does not corrupt the others. The contract is not overhead, it is the entire reason fan out works at scale. Without it, parallel becomes chaos. With it, parallel becomes predictable. Let's recap with Claude. A custom tool

[3:08] Becomes the orchestration trigger. When the head calls dispatch analysts, the server intercepts and spawns independent sessions. Each analyst runs in parallel with its own context window. The server fans them in when all finish. The head never blocked, it waited while the server did the coordination. Return, here's the prompt. Fan this workload out across parallel sub agents, then merge the results into one ranked decision. What you are building is the server-side intercept, the moment where a tool call leaves the agent's context and becomes the server's responsibility. Watch what happens when one analyst fails. Does the head get a partial result, or does it wait for a retry?

[3:42] Watch what happens when all three finish at different times. Does the merge happen immediately? Or does the server collect the slowest one? The fan out shape is simple. The failure modes are where the lives. Take this prompt, run it on your own workload, and watch the parallel sessions appear. Lay them in for bare. Fan out coordinating doesn't