From cc148ab62ddd48f7f51302912cf4eb6d80d99734 Mon Sep 17 00:00:00 2001 From: Brandon Baker Date: Thu, 1 May 2025 09:50:08 +0100 Subject: [PATCH 1/3] Add cookbook notebook for parallel agents Adds a cookbook notebook demonstrating how to run agents in parallel, chain the output from parallel calls to another agent, and visualize the execution timeline of the agents. --- examples/agents_sdk/parallel_agents.ipynb | 243 ++++++++++++++++++++++ registry.yaml | 10 + 2 files changed, 253 insertions(+) create mode 100644 examples/agents_sdk/parallel_agents.ipynb diff --git a/examples/agents_sdk/parallel_agents.ipynb b/examples/agents_sdk/parallel_agents.ipynb new file mode 100644 index 0000000000..2a1531dd73 --- /dev/null +++ b/examples/agents_sdk/parallel_agents.ipynb @@ -0,0 +1,243 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Running Specialized Agents in Parallel with the OpenAI Agents SDK\n", + "\n", + "Why would you want to do this?\n", + "In many production workflows you must answer several independent questions about the same piece of content.\n", + "Doing those analyses one-by-one increases latency and can increase total cost if any step fails and forces a retry.\n", + "By \"fanning out\" multiple specialized agents at the same time and then \"fanning in\" their outputs to a final “meta” agent, you're able to reduce this latency.\n", + "\n", + "This notebook present a toy example that you likely wouldn't parallelize in the real world, but that shows:\n", + "1. How to define several focused agents with the OpenAI Agents SDK.\n", + "2. How to execute them concurrently using Python `asyncio`.\n", + "3. How to gather their individual outputs and feed them into a downstream meta-agent that produces the final, user-ready answer.\n", + "4. A simple timeline visualization so you can see the latency benefit of parallelization.\n", + "\n", + "This same pattern can be adapted to real world scenarios such as customer-support triage, content moderation, or other scenarios where you might want to run multiple independent analyses on an input and merge them into a single outcome." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Install dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install openai-agents asyncio matplotlib nest_asyncio\n", + "\n", + "import time\n", + "\n", + "import asyncio\n", + "import matplotlib.pyplot as plt\n", + "import nest_asyncio\n", + "\n", + "from agents import Agent, Runner\n", + "\n", + "nest_asyncio.apply()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Define your Agents" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# Agent focusing on product features\n", + "features_agent = Agent(\n", + " name=\"FeaturesAgent\",\n", + " instructions=\"Extract the key product features from the review.\"\n", + ")\n", + "\n", + "# Agent focusing on pros & cons\n", + "pros_cons_agent = Agent(\n", + " name=\"ProsConsAgent\",\n", + " instructions=\"List the pros and cons mentioned in the review.\"\n", + ")\n", + "\n", + "# Agent focusing on sentiment analysis\n", + "sentiment_agent = Agent(\n", + " name=\"SentimentAgent\",\n", + " instructions=\"Summarize the overall user sentiment from the review.\"\n", + ")\n", + "\n", + "# Agent focusing on recommendation summary\n", + "recommend_agent = Agent(\n", + " name=\"RecommendAgent\",\n", + " instructions=\"State whether you would recommend this product and why.\"\n", + ")\n", + "\n", + "parallel_agents = [\n", + " features_agent,\n", + " pros_cons_agent,\n", + " sentiment_agent,\n", + " recommend_agent\n", + "]\n", + "\n", + "# Meta-agent to combine outputs\n", + "meta_agent = Agent(\n", + " name=\"MetaAgent\",\n", + " instructions=\"You are given multiple summaries labeled with Features, ProsCons, Sentiment, and a Recommendation.\"\n", + " \" Combine them into a concise executive summary of the product review with a 1-5 star rating for each summary area.\"\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "starts, ends = [], []\n", + "async def run_agent(agent, review_text: str):\n", + " agent_name = agent.name\n", + "\n", + " start = time.time()\n", + " starts.append((agent_name, start))\n", + "\n", + " result = await Runner.run(agent, review_text)\n", + "\n", + " end = time.time()\n", + " ends.append((agent_name, end))\n", + "\n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Create function for parallel execution" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "async def run_agents(review_text: str):\n", + " responses = await asyncio.gather(\n", + " *(run_agent(agent, review_text) for agent in parallel_agents)\n", + " )\n", + "\n", + " labeled_summaries = [\n", + " f\"### {resp.last_agent.name}\\n{resp.final_output}\"\n", + " for resp in responses\n", + " ]\n", + "\n", + " collected_summaries = \"\\n\".join(labeled_summaries)\n", + " final_summary = await run_agent(meta_agent, collected_summaries)\n", + "\n", + "\n", + " print('Final summary:', final_summary.final_output)\n", + "\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final summary: ### Executive Summary\n", + "\n", + "**AuroraSound X2 Wireless Noise-Cancelling Headphones**\n", + "\n", + "**Features (4/5):** \n", + "The AuroraSound X2 boasts a premium design with matte‐finish ear cups and a memory‐foam headband ensuring comfort during long usage. Connectivity is seamless via Bluetooth 5.2, and the headphones offer effective active noise-cancelling (ANC) and a well-tuned \"Transparency\" mode. Audio quality is superior, with rich sound supported by customizable EQ presets. Though the touch controls are intuitive, they can be overly sensitive. The battery life is impressive, offering over 30 hours with ANC and a quick-charge feature. However, the carrying case is bulky, and color choices are limited to black or white.\n", + "\n", + "**Pros & Cons (4/5):** \n", + "Pros include the premium design, comfort, seamless connectivity, excellent noise-cancelling, rich audio quality, and long battery life. Cons are minor, including the bulky carrying case, touch interface sensitivity, and limited color options. \n", + "\n", + "**Sentiment (5/5):** \n", + "User sentiment is overwhelmingly positive, highlighting the headphones' design, noise-cancellation, sound quality, and connectivity. Minor issues with the carrying case and touch controls do not significantly impact the overall satisfaction.\n", + "\n", + "**Recommendation (5/5):** \n", + "The AuroraSound X2 is highly recommended for its design, comfort, impressive connectivity, and noise-cancelling capabilities. Despite minor drawbacks, the headphones' performance, sound quality, and features make it a solid choice for high-quality audio needs.\n", + "\n", + "**Overall Rating: 4.5/5** \n", + "The AuroraSound X2 offers a compelling package for those seeking premium wireless noise-cancelling headphones, making it a worthy investment.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "review_text = \"\"\"\n", + "I recently upgraded to the AuroraSound X2 wireless noise-cancelling headphones, and after two weeks of daily use I have quite a bit to share. First off, the design feels premium without being flashy: the matte‐finish ear cups are softly padded and rotate smoothly for storage, while the headband’s memory‐foam cushion barely presses on my temples even after marathon work calls. Connectivity is seamless—pairing with my laptop and phone took under five seconds each time, and the Bluetooth 5.2 link held rock-solid through walls and down the hallway.\n", + "\n", + "The noise-cancelling performance is genuinely impressive. In a busy café with music and chatter swirling around, flipping on ANC immediately quiets low-level ambient hums, and it even attenuates sudden noises—like the barista’s milk frother—without sounding distorted. The “Transparency” mode is equally well‐tuned: voices come through clearly, but the world outside isn’t overwhelmingly loud. Audio quality in standard mode is rich and balanced, with tight bass, clear mids, and a hint of sparkle in the highs. There’s also a dedicated EQ app, where you can toggle between “Podcast,” “Bass Boost,” and “Concert Hall” presets or craft your own curve.\n", + "\n", + "On the control front, intuitive touch panels let you play/pause, skip tracks, and adjust volume with a simple swipe or tap. One neat trick: holding down on the right ear cup invokes your phone’s voice assistant. Battery life lives up to the hype, too—over 30 hours with ANC on, and the quick‐charge feature delivers 2 hours of playtime from just a 10-minute top-up.\n", + "\n", + "That said, it isn’t perfect. For one, the carrying case is a bit bulky, so it doesn’t slip easily into a slim bag. And while the touch interface is mostly reliable, I occasionally trigger a pause when trying to adjust the cup position. The headphones also come in only two colorways—black or white—which feels limiting given the premium price point.\n", + "\"\"\"\n", + "\n", + "asyncio.get_event_loop().run_until_complete(run_agents(review_text))\n", + "\n", + "# Plot the timeline of the agents\n", + "# normalize times to zero\n", + "base = min(t for _, t in starts)\n", + "labels = [n for n, _ in starts]\n", + "start_offsets = [t - base for _, t in starts]\n", + "lengths = [ends[i][1] - starts[i][1] for i in range(len(starts))]\n", + "\n", + "plt.figure(figsize=(8, 3))\n", + "plt.barh(labels, lengths, left=start_offsets)\n", + "plt.xlabel(\"Seconds since kickoff\")\n", + "plt.title(\"Agent Execution Timeline\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/registry.yaml b/registry.yaml index 92293b7a24..07e81306f0 100644 --- a/registry.yaml +++ b/registry.yaml @@ -1936,3 +1936,13 @@ - functions - responses - api + +- title: Parallel Agents with the OpenAI Agents SDK + path: examples/agents_sdk/parallel_agents.ipynb + date: 2025-05-01 + authors: + - brandonbaker-openai + tags: + - agents + - agents-sdk + - parallel-agents From 368fa9d21b2f7ec26170229abf1374ac901dfdb9 Mon Sep 17 00:00:00 2001 From: Brandon Baker Date: Mon, 5 May 2025 12:42:41 -0400 Subject: [PATCH 2/3] Update with another approach --- examples/agents_sdk/parallel_agents.ipynb | 155 ++++++++++++++++++---- 1 file changed, 126 insertions(+), 29 deletions(-) diff --git a/examples/agents_sdk/parallel_agents.ipynb b/examples/agents_sdk/parallel_agents.ipynb index 2a1531dd73..8aace6ccfe 100644 --- a/examples/agents_sdk/parallel_agents.ipynb +++ b/examples/agents_sdk/parallel_agents.ipynb @@ -13,7 +13,7 @@ "\n", "This notebook present a toy example that you likely wouldn't parallelize in the real world, but that shows:\n", "1. How to define several focused agents with the OpenAI Agents SDK.\n", - "2. How to execute them concurrently using Python `asyncio`.\n", + "2. How to execute them concurrently using either Python `asyncio` for lower latency, lightweight parallelization or directly through the SDK for ease of management and dynamic tool call planning.\n", "3. How to gather their individual outputs and feed them into a downstream meta-agent that produces the final, user-ready answer.\n", "4. A simple timeline visualization so you can see the latency benefit of parallelization.\n", "\n", @@ -55,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -162,27 +162,25 @@ "text": [ "Final summary: ### Executive Summary\n", "\n", - "**AuroraSound X2 Wireless Noise-Cancelling Headphones**\n", + "The AuroraSound X2 wireless noise-cancelling headphones offer a blend of premium design and advanced features. The headphones boast a matte-finish with comfortable, memory-foam padding, making them ideal for extended use. With Bluetooth 5.2, they provide seamless connectivity and stable communication. The noise-cancelling capabilities effectively reduce ambient noise and feature a well-tuned Transparency mode for essential sound transmission.\n", "\n", - "**Features (4/5):** \n", - "The AuroraSound X2 boasts a premium design with matte‐finish ear cups and a memory‐foam headband ensuring comfort during long usage. Connectivity is seamless via Bluetooth 5.2, and the headphones offer effective active noise-cancelling (ANC) and a well-tuned \"Transparency\" mode. Audio quality is superior, with rich sound supported by customizable EQ presets. Though the touch controls are intuitive, they can be overly sensitive. The battery life is impressive, offering over 30 hours with ANC and a quick-charge feature. However, the carrying case is bulky, and color choices are limited to black or white.\n", + "**Audio Quality** is a highlight, delivering rich, balanced sound with customizable EQ presets including “Podcast,” “Bass Boost,” and “Concert Hall.” Intuitive touch controls allow for easy navigation, though some users report occasional misfires. The extended battery life offers over 30 hours with ANC on, with a quick-charge option for convenience.\n", "\n", - "**Pros & Cons (4/5):** \n", - "Pros include the premium design, comfort, seamless connectivity, excellent noise-cancelling, rich audio quality, and long battery life. Cons are minor, including the bulky carrying case, touch interface sensitivity, and limited color options. \n", + "**Minor Limitations** include a bulky carrying case, occasional touch control issues, and limited color choices (black or white). Despite these, the overall sentiment is highly positive, with users particularly appreciating the headphones' design, connectivity, and performance. The product is recommended for those seeking high-quality audio experiences with effective noise-cancelling features.\n", "\n", - "**Sentiment (5/5):** \n", - "User sentiment is overwhelmingly positive, highlighting the headphones' design, noise-cancellation, sound quality, and connectivity. Minor issues with the carrying case and touch controls do not significantly impact the overall satisfaction.\n", + "### Star Ratings\n", "\n", - "**Recommendation (5/5):** \n", - "The AuroraSound X2 is highly recommended for its design, comfort, impressive connectivity, and noise-cancelling capabilities. Despite minor drawbacks, the headphones' performance, sound quality, and features make it a solid choice for high-quality audio needs.\n", + "- **Features**: ★★★★☆\n", + "- **Pros & Cons**: ★★★★☆\n", + "- **Sentiment**: ★★★★★\n", + "- **Recommendation**: ★★★★★\n", "\n", - "**Overall Rating: 4.5/5** \n", - "The AuroraSound X2 offers a compelling package for those seeking premium wireless noise-cancelling headphones, making it a worthy investment.\n" + "Overall, the AuroraSound X2 headphones are a compelling choice, offering excellent value despite minor drawbacks.\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -204,18 +202,117 @@ "\n", "asyncio.get_event_loop().run_until_complete(run_agents(review_text))\n", "\n", - "# Plot the timeline of the agents\n", - "# normalize times to zero\n", - "base = min(t for _, t in starts)\n", - "labels = [n for n, _ in starts]\n", - "start_offsets = [t - base for _, t in starts]\n", - "lengths = [ends[i][1] - starts[i][1] for i in range(len(starts))]\n", - "\n", - "plt.figure(figsize=(8, 3))\n", - "plt.barh(labels, lengths, left=start_offsets)\n", - "plt.xlabel(\"Seconds since kickoff\")\n", - "plt.title(\"Agent Execution Timeline\")\n", - "plt.show()" + "def plot_timeline(starts, ends):\n", + "\n", + " # Plot the timeline of the agents\n", + " # normalize times to zero\n", + " base = min(t for _, t in starts)\n", + " labels = [n for n, _ in starts]\n", + " start_offsets = [t - base for _, t in starts]\n", + " lengths = [ends[i][1] - starts[i][1] for i in range(len(starts))]\n", + "\n", + " plt.figure(figsize=(8, 3))\n", + " plt.barh(labels, lengths, left=start_offsets)\n", + " plt.xlabel(\"Seconds since kickoff\")\n", + " plt.title(\"Agent Execution Timeline\")\n", + " plt.show()\n", + "\n", + "plot_timeline(starts, ends)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The agents can also be parallelized directly through the SDK via the \"agent as tool\" route, adding convenience and the assistance of the planner dynamically deciding which tools to call at the expense of higher latency. This latency comes both from the additional planning API call up front, along with the higher overhead and context from the tool call objects." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final summary: **Executive Summary: AuroraSound X2 Wireless Noise-Cancelling Headphones**\n", + "\n", + "**Features (⭐️⭐️⭐️⭐️⭐️ 5/5):** The headphones boast a premium, matte-finish design with comfortable memory-foam cushioning. They offer seamless Bluetooth 5.2 connectivity, impressive noise-cancelling capabilities, and a well-tuned \"Transparency\" mode. The audio quality is rich and balanced, with customizable sound options via a dedicated EQ app. Additional features include intuitive touch controls and excellent battery life paired with a quick-charge option.\n", + "\n", + "**Pros and Cons (⭐️⭐️⭐️⭐️ 4/5):** \n", + "- **Pros:** Premium design, comfortable fit, seamless connectivity, effective noise-cancelling, clear voice input in \"Transparency\" mode, customizable audio, intuitive controls, long battery life.\n", + "- **Cons:** Bulky carrying case, occasional touch control sensitivity issues, limited color options.\n", + "\n", + "**Sentiment (⭐️⭐️⭐️⭐️ 4/5):** The overall sentiment is highly positive, with appreciation for the design, comfort, connectivity, noise-cancelling effectiveness, and audio quality. Minor drawbacks are noted but do not outweigh the benefits.\n", + "\n", + "**Recommendation (⭐️⭐️⭐️⭐️ 4/5):** Highly recommended for those seeking premium noise-cancelling headphones with versatile features and excellent audio performance. The minor drawbacks are outweighed by the comprehensive suite of high-quality features.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from agents import ModelSettings\n", + "\n", + "\n", + "meta_agent_parallel_tools = Agent(\n", + " name=\"MetaAgent\",\n", + " instructions=\"You are given multiple summaries labeled with Features, ProsCons, Sentiment, and a Recommendation.\"\n", + " \" Combine them into a concise executive summary of the product review with a 1-5 star rating for each summary area.\",\n", + " model_settings=ModelSettings(\n", + " parallel_tool_calls=True\n", + " ),\n", + " tools=[\n", + " features_agent.as_tool(\n", + " tool_name=\"features\",\n", + " tool_description=\"Extract the key product features from the review.\",\n", + " ),\n", + " pros_cons_agent.as_tool(\n", + " tool_name=\"pros_cons\",\n", + " tool_description=\"List the pros and cons mentioned in the review.\",\n", + " ),\n", + " sentiment_agent.as_tool(\n", + " tool_name=\"sentiment\",\n", + " tool_description=\"Summarize the overall user sentiment from the review.\",\n", + " ),\n", + " recommend_agent.as_tool(\n", + " tool_name=\"recommend\",\n", + " tool_description=\"State whether you would recommend this product and why.\",\n", + " ),\n", + " ],\n", + ")\n", + "\n", + "starts, ends = [], []\n", + "result = await run_agent(meta_agent_parallel_tools, review_text)\n", + "\n", + "print('Final summary:', result.final_output)\n", + "\n", + "plot_timeline(starts, ends)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "From the above, we can see two different patterns for parallelizing agents. Ultimately, the approach you use will depend on the balance you want between:\n", + "\n", + "1. Convenience vs. customization\n", + " * If you prefer convenience, the agent as tool route is the way to go. If you want to customize how agents fan in and out across multiple layers, building a graph with `asyncio.gather` might make more sense\n", + "1. Planning vs. determinism\n", + " * If you want your planner (in this case the meta agent) to dynamically decide which tools to call and the order, you should use agents as tools whereas `asyncio.gather` makes more sense if you want a deterministic order.\n", + "1. Latency sensitivity\n", + " * If you're highly sensitive to latency, you may want to use `asyncio` to avoid the additional upfront cost of planning the parallel tools and the overhead of tool outputs and longer context windows." ] } ], From 89ad0aef718c9a8e3a677e186c46ed1284d3acc8 Mon Sep 17 00:00:00 2001 From: Brandon Baker Date: Tue, 6 May 2025 09:14:02 -0400 Subject: [PATCH 3/3] Add links --- examples/agents_sdk/parallel_agents.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/agents_sdk/parallel_agents.ipynb b/examples/agents_sdk/parallel_agents.ipynb index 8aace6ccfe..a6f4e0ce48 100644 --- a/examples/agents_sdk/parallel_agents.ipynb +++ b/examples/agents_sdk/parallel_agents.ipynb @@ -13,7 +13,7 @@ "\n", "This notebook present a toy example that you likely wouldn't parallelize in the real world, but that shows:\n", "1. How to define several focused agents with the OpenAI Agents SDK.\n", - "2. How to execute them concurrently using either Python `asyncio` for lower latency, lightweight parallelization or directly through the SDK for ease of management and dynamic tool call planning.\n", + "2. How to execute them concurrently using either Python [asyncio](https://docs.python.org/3/library/asyncio.html) for lower latency, lightweight parallelization or directly through the [Agents SDK](https://openai.github.io/openai-agents-python/tools/#agents-as-tools) for ease of management and dynamic tool call planning.\n", "3. How to gather their individual outputs and feed them into a downstream meta-agent that produces the final, user-ready answer.\n", "4. A simple timeline visualization so you can see the latency benefit of parallelization.\n", "\n",