Run Specialized Agents in Parallel

This notebook demonstrates running several specialized agents concurrently to answer independent questions about the exact same piece of content, then feeding all of their outputs into a downstream meta-agent that produces the final, user-facing answer. Running analyses one at a time increases both overall latency and, if any single step fails and needs a retry, the total cost - fanning multiple agents out in parallel and fanning their results back in together reduces that latency considerably.

Use this pattern when a production workflow needs several independent analyses run on the same input and merged into one outcome - customer-support triage, content moderation, or similar multi-angle analysis scenarios. The toy example in the notebook is intentionally one you likely wouldn't parallelize for real, chosen purely to demonstrate the mechanics rather than to model a genuine production case.

Two distinct ways to run agents concurrently are shown: Python's asyncio (asyncio.gather) for lightweight, lower-latency parallelization with a deterministic execution order, and the Agents SDK's own "agents as tools" approach, which lets a planner dynamically decide which tools to call and in what order at the cost of extra latency from the planning call itself and the added tool-call overhead and context. A simple timeline visualization included in the notebook makes the latency difference between running agents serially versus in parallel visible directly.

The choice between the two approaches comes down to three tradeoffs: convenience versus customization (agents-as-tools is more convenient; asyncio.gather gives more control over how fan-out and fan-in compose across multiple layers), planning versus determinism (agents-as-tools lets a meta-agent planner decide dynamically; asyncio.gather runs a fixed, deterministic order), and latency sensitivity (asyncio avoids the extra planning call and tool-call overhead that agents-as-tools introduces).

Developers and teams building OpenAI Agents SDK workflows that need multiple independent analyses on the same input merged into a single answer, who need to choose between asyncio-based determinism and SDK-native dynamic tool planning based on their latency and control requirements. The notebook walks through this in four concrete steps - installing dependencies, defining the individual specialized agents, writing the function that runs them in parallel, and wiring their combined outputs into the final meta-agent - making it straightforward to adapt the same four-step structure to a real production workflow rather than the toy example shown here.