Launching Concurrent Agents

Welcome to another step in this journey! In previous lessons, you learned how to build sophisticated agent systems that can use tools, handle multi-turn conversations, and even transfer control between specialized agents. You also learned the basics of concurrent execution in TypeScript using Promises to make multiple GPT-5 calls simultaneously. Now it’s time to bring these concepts together and learn how to run multiple independent agent conversations concurrently, significantly improving the performance of your agentic systems.

In this lesson, our Agent is implemented on top of the OpenAI Responses API (client.responses.create) and uses function calling (tools) as part of the agent loop.

Let’s start by understanding what happens when we run agent conversations one after another. Consider a scenario where you have multiple math problems to solve. The straightforward approach would be to process each problem sequentially, waiting for one to complete before starting the next.

const prompts = [
  "Solve this: (2 + 3) * (4*4)",
  "Find the roots of x^2 - 5x + 6 = 0",
];

const agent = new Agent({
  name: "math_assistant",
  systemPrompt:
    "You are a calculator assistant. Always use the available tools to perform calculations accurately.",
  tools,
  toolSchemas,
  maxTurns: 15
});

// Process each prompt one at a time
for (const prompt of prompts) {
  const [_, result] = await agent.run([{ role: "user", content: prompt }]);
  console.log(result);
}

In this approach, the second conversation doesn’t start until the first one is completely finished. If the first conversation takes 5 seconds and the second takes 4 seconds, the total execution time is 9 seconds. The bottleneck here is clear: we’re forcing conversations to wait unnecessarily, even though they’re completely independent and could theoretically run at the same time.

Now let’s transform our serial approach into concurrent execution. The key is to create all our agent conversation tasks upfront without immediately waiting for them to complete.

const prompts = [
  "Solve this: (2 + 3) * (4*4)",
  "Find the roots of x^2 - 5x + 6 = 0",
];

const agent = new Agent({
  name: "math_assistant",
  systemPrompt:
    "You are a calculator assistant. Always use the available tools to perform calculations accurately.",
  tools,
  toolSchemas,
  maxTurns: 15
});

// Create a list of promise tasks, one for each prompt
const tasks = prompts.map(prompt =>
  agent.run([{ role: "user", content: prompt }])
);

We use map to create an array of tasks, where each task is a call to agent.run(). Notice we’re not using await inside the map function. In JavaScript, Promises are eager, meaning that as soon as agent.run() is called, the network request and agent logic begin executing.

Once we have our array of tasks, we can wait for all conversations to finish using Promise.all.

// Wait for all concurrent tasks to complete and collect their results
const results = await Promise.all(tasks);

// Display the final response from each conversation
results.forEach(([_, result], idx) => {
  console.log(`\n=== run ${idx + 1} ===`);
  console.log(result);
});

When you run this code, you’ll see output that demonstrates the concurrent nature of the execution. The tool calls from both conversations can appear interleaved, showing that both agents are actively working at the same time:

🔧 Tool called: sum_numbers({"a":2,"b":3})
🔧 Tool called: multiply_numbers({"a":4,"b":4})
🔧 Tool called: multiply_numbers({"a":5,"b":16})
🔧 Tool called: power({"base":-5,"exponent":2})
🔧 Tool called: subtract_numbers({"a":25,"b":24})
🔧 Tool called: square_root({"number":1})
🔧 Tool called: divide_numbers({"a":5,"b":2})
🔧 Tool called: divide_numbers({"a":1,"b":2})
🔧 Tool called: sum_numbers({"a":2.5,"b":0.5})

=== run 1 ===
80

=== run 2 ===
The roots are x = 2 and x = 3.

The results array contains the outcomes in the same order as the original prompts, regardless of which conversation finished first. Notice how the tool calls from both conversations are interleaved in the output, confirming that both conversations are running simultaneously.

It is important to remember that Promise.all follows an "all-or-nothing" strategy. If any single conversation fails and its promise rejects, the entire Promise.all call will immediately reject, losing access to the results of the successful conversations. In workflows where you want to keep partial results even if one agent crashes, consider using Promise.allSettled(). This ensures you can inspect which conversations succeeded and which failed individually.

You might wonder whether it’s safe to use the same agent instance for multiple concurrent conversations. The answer is yes, and understanding why is important for writing efficient code.

public async run(
  inputMessages: Array<Record<string, unknown>>
): Promise<[Array<Record<string, unknown>>, string]> {
  const messages = [...inputMessages];  // Creates a new array for this conversation

  let turn = 0;
  while (turn < this.maxTurns) {
    // All operations work with this conversation's messages array
    // Other concurrent conversations have their own separate arrays
  }
}

When you call agent.run(), you pass in an initial messages array that represents the conversation history. Each call to run() creates a local copy of that array and builds upon it throughout the conversation. This means each concurrent conversation maintains its own separate state.

The agent’s configuration—like systemPrompt, tools, toolSchemas, model, and reasoningEffort—is read-only during execution, so multiple conversations can safely read these shared properties simultaneously without interfering with each other.

Let’s examine the concrete performance benefits of concurrent execution. Imagine you have two conversations: one takes 5 seconds to complete and another takes 4 seconds.

Serial execution:
Conversation 1: [=====] (5 seconds)
Conversation 2:        [====] (4 seconds)
Total time: 9 seconds

Concurrent execution:
Conversation 1: [=====] (5 seconds)
Conversation 2: [====]  (4 seconds)
Total time: 5 seconds

With serial execution, the total time is the sum of all individual conversation times. With concurrent execution, all conversations start at once, and the total execution time becomes the duration of the longest conversation.

While we’re running multiple conversations concurrently, it’s important to understand what remains sequential. Within each individual conversation, tools are always executed serially, one at a time, even when the model requests multiple tools in a single turn.

In your agent loop, tool calls are extracted from response.output:

const functionCalls = response.output.filter(
  (item): item is FunctionCallItem => item.type === "function_call"
);

Then they’re executed with a for loop:

for (const functionCall of functionCalls) {
  const toolResult = await this.callTool(functionCall);
  functionOutputs.push(toolResult);
}

This means even when the model requests multiple independent function calls, they execute one after another within that conversation. The interleaving you see in the logs happens because conversation A and conversation B are progressing concurrently, not because tools inside a single conversation are parallel.

This design keeps the code simple and predictable, but tools that involve I/O operations, like making network API calls, could run concurrently to save time when the tool calls are independent. We’ll explore these optimization techniques in future lessons.

You’ve now learned how to run multiple independent agent conversations concurrently using Promise.all, transforming serial execution into parallel processing. You discovered that a single agent instance can safely handle multiple concurrent conversations because each maintains its own isolated messages array.

Now you’re ready to practice implementing concurrent agent conversations!