OpenAI’s Multi-Agent Responses API Beta: How Parallel Subagents Work

OpenAI’s Multi-Agent beta for the Responses API gives GPT-5.6 a hosted way to delegate work. A root agent can create focused subagents, let them proceed concurrently, exchange messages, wait for results, and synthesize one final response—all inside the API’s orchestration model.

The feature arrived with the GPT-5.6 general-availability release on July 9, 2026. OpenAI documents it as a beta available across Sol, Terra, and Luna. “Beta” is operationally important: request headers and item schemas may change, so teams should isolate the integration, pin SDK versions, and avoid making an experimental response format the permanent schema of their own product.

Multi-agent is not a magic accuracy switch. Its value comes from task structure. If three pieces of work are independent, three focused contexts may finish sooner and cover more ground. If every step depends on the prior result, adding agents creates conversation overhead without useful parallelism.

The root-and-subagent model

When multi-agent mode is enabled, the root model becomes eligible to spawn a hierarchy of subagents. Each receives a bounded task and its own context. The root can send additional information, wait for updates, and reconcile results.

The subagents share the model selected for the Responses request and the tools configured in that request. A Sol root therefore does not automatically dispatch Luna workers. If a product needs heterogeneous model routing, its application must create that architecture separately rather than assume the beta performs it.

OpenAI provides hosted collaboration actions for spawning, messaging, assigning follow-up work, waiting, interrupting, and listing the agent tree. Applications may observe those actions as multi-agent response items, but should not try to execute them as ordinary custom function calls. Developer-defined functions still follow the normal pattern: an agent emits the call, the application executes it, and the matching output is returned.

The root remains responsible for the final synthesis. Subagent responses are evidence and work products, not independent final answers delivered directly to the user.

What parallel subagents improve

The official guide highlights three advantages:

• Parallel execution: independent research or implementation can proceed at the same time.
• Focused context: each agent concentrates on a bounded problem rather than mixing unrelated material.
• Model-directed coordination: the root decides how to delegate and reconcile work without the application implementing every branch in advance.

Good task shapes include separate codebase explorations, comparisons of multiple documents or hypotheses, research across independent sources, independent components or test suites, and parallel investigations of possible failure causes.

The deeper benefit is context isolation. A security reviewer does not need the brainstorming history of a documentation writer. A source-checking agent can work from primary documents while another tests implementation assumptions. The root receives narrower outputs that are easier to compare.

When one agent is better

Parallel agents are a poor fit when:

• each action depends directly on the exact output of the previous action;
• several agents would edit the same mutable resource;
• the task is small enough for one short run;
• the execution graph must be fixed and deterministic;
• one slow external service dominates elapsed time;
• synthesis costs more than the separate work saves.

A video render illustrates the last point. Four agents cannot make one external render complete four times faster. They may prepare metadata or review separate assets in parallel, but the critical path still contains the same render.

Multi-agent also increases token consumption. Each subagent needs instructions and context, produces intermediate output, and may call tools. Wall-clock time can fall while spend rises. The business question is whether faster completion or better coverage is worth that difference.

Concurrency and tree structure

The beta exposes a maximum concurrent subagent setting. OpenAI’s documentation says the default is three and recommends that value for most workloads. The limit applies across the active agent tree, including descendants, but excludes the root.

The API does not impose a fixed maximum tree depth or total number of subagents in the documented beta. That is not an invitation to create an unbounded organization chart. Applications should enforce their own budgets for:

• total subagents created;
• concurrent active agents;
• aggregate tokens and tool calls;
• elapsed time;
• retries and follow-up turns;
• maximum depth;
• number and size of artifacts returned to the root.

Without budgets, a model can rationally keep investigating because the prompt says “be thorough,” even when the marginal value is low.

HTTP, WebSocket, and tool-heavy runs

OpenAI supports both HTTP and WebSocket paths for the beta. The documentation recommends WebSocket for many tool-heavy or long-running workflows because function outputs can be returned as they become available. A waiting agent can resume while others continue.

With HTTP, the response waits until active agents either finish or pause for client-executed function calls. The application executes outstanding calls and continues the response. That may be sufficient for hosted tools or simple one-request research, but asynchronous tool completions can introduce extra waiting and continuation overhead.

Transport choice does not solve workflow design. An application still needs correlation IDs, durable state for external jobs, timeout policies, and a way to recover after a dropped connection.

Synthesis is the hard part

Parallel research can produce conflicting answers, duplicate findings, inconsistent terminology, and different levels of evidence. A good root instruction defines how to reconcile them.

Useful synthesis requirements include:

1. preserve source or artifact identifiers;
2. separate observed facts from inference;
3. identify disagreements rather than averaging them away;
4. deduplicate equivalent findings;
5. prioritize by explicit criteria;
6. report missing evidence and failed workstreams;
7. avoid claiming completion until required validators pass.

For important workflows, use an independent deterministic check or a human reviewer after synthesis. A model-generated consensus is not proof that all subagents were correct.

Production risks and evaluation

Every subagent inherits access to the tools configured in the request. That makes least privilege essential. If a research subagent only needs file search, do not expose a publishing or deletion tool merely because the root might need it later.

Prompt injection can also cross boundaries. A subagent reading an untrusted webpage may return malicious instructions as if they were findings. Root instructions should treat subagent output as untrusted data, retain provenance, and require approval for consequential actions.

Evaluate multi-agent against a strong single-agent baseline. Compare task success, wall-clock time, total tokens, tool calls, reviewer corrections, and failure recovery. The feature earns its place only if it improves the metric the product actually values.

From parallel agents to a production media workflow

A media campaign can contain genuinely independent workstreams: one agent checks source files and usage rights, another prepares a narration plan, another verifies brand specifications, and another checks final deliverables. Those tasks can proceed in parallel. The transformations themselves should be sent to specialized media tools only after the root has reconciled requirements.

For example, a document-driven campaign might have one subagent identify sections of a PDF, a second draft short scripts, and a third prepare output specifications. After human approval, Claude or Codex can call an external service such as Medux to merge approved PDF files or assemble approved video clips. This is workflow composition, not a claim that Medux natively embeds GPT-5.6.

The Claude MCP PDF tutorial demonstrates an asynchronous document operation using uploads, a task request, polling, and download. The video merge tutorial demonstrates the equivalent pattern for multiple clips.

A safe multi-agent version would:

• delegate only read-only inspection and planning at first;
• have the root produce one validated manifest with ordered inputs;
• request human approval for the selected files and operation;
• create one idempotent external media job;
• store its task ID outside transient agent context;
• let one monitor—not several competing agents—poll the job;
• run independent technical and editorial checks on the completed artifact.

Parallelism belongs around the bottleneck, not inside every step. Used that way, Multi-Agent Responses can improve preparation and review while the media service remains a separate, auditable production layer.