मुख्य कंटेंट तक स्किप करें

Native Multi-Agent APIs: OpenAI's Responses Multi-Agent Beta vs Building It Yourself

उन्नत

For eighteen months, "multi-agent" meant you wrote the fan-out. You wrote the coordinator prompt, you spawned N calls in parallel, you merged their JSON, you handled the retries. On 9 July 2026 OpenAI collapsed that into a request parameter: multi_agent.enabled: true on the Responses API, wrapped in a consumer feature called Sol Ultra Mode. The model itself decides how many subagents to spawn, runs them in parallel, and synthesises the result — all inside a single HTTP call. No other frontier vendor has shipped a symmetric primitive. This page maps what actually shipped, the numbers behind it, what Anthropic offers instead, and — the part that matters — the three workloads where the native primitive earns its cost and the two where a DIY fan-out still wins.

What you'll learn
  • Read the exact Responses API multi-agent request body and know what max_concurrent_subagents actually caps
  • Do the cost math: what 'the model spawns 4 subagents' actually charges you at Sol prices
  • Map the same territory on Anthropic's side — Cowork, Managed Agents, and Claude Code subagents — and see the primitive gap
  • Pick the right primitive per workload: native multi-agent, DIY fan-out, A2A, or a single long turn
  • Avoid the four failure modes that turn a 4-agent Ultra call into a 4x bill with no accuracy win

The one-sentence version​

Ultra Mode is a consumer skin over multi_agent.enabled: true on the Responses API — a native primitive that lets the model spawn subagents in parallel inside one request, synthesise their outputs, and return a single response. It buys you a small-but-real accuracy bump on parallelisable tasks (Terminal-Bench 2.1: 88.8% → 91.9%), at a token bill that scales roughly linearly with the number of subagents the model chooses to spawn.

What actually shipped on 9 July 2026​

Two things landed in the same launch, and it is worth separating them:

  • Ultra Mode — a product toggle inside ChatGPT and Codex. Available on the flagship tier (Sol). When enabled, hard tasks get decomposed into parallel subagent runs before synthesis. Marketed as "spawns 4+ agents"; a few of OpenAI's own GA benchmark charts also show 16-agent configurations on BrowseComp and SEC-Bench Pro, but four is the working default.
  • Responses API multi-agent beta — a developer primitive. The same underlying capability, exposed as multi_agent.enabled: true on client.beta.responses.create(). This is what you'd use to build your own Ultra-like experience.

The confusion the marketing left is real: builders keep asking "how do I call Ultra Mode from the API?" The answer is that you don't — you enable the multi-agent beta, which is the primitive under the product feature.

The Responses API multi-agent request​

Concretely, this is the shape (Python SDK):

Minimal multi-agent Responses API call

from openai import OpenAI

client = OpenAI()

resp = client.beta.responses.create(
  model="gpt-5.6-sol",
  input="Audit this repo for auth-bypass patterns and write a report.",
  multi_agent={
      "enabled": True,
      "max_concurrent_subagents": 3,
  },
  tools=[...],  # your MCP tools, function tools, etc.
  extra_headers={"OpenAI-Beta": "responses_multi_agent=v1"},
)

Four things about this shape are non-obvious:

  • max_concurrent_subagents is not a total budget. It caps active subagent turns across the entire tree at any given moment — root plus descendants. The model can spawn a much larger total number of subagents over the life of the request; it just cannot have more than N running at once.
  • Depth is unbounded. A subagent can itself spawn subagents. There is no fixed cap on tree depth or on total subagent count per run. Your cost surface is not "N calls" — it is a tree the model shapes at runtime.
  • The root synthesises. The root agent is responsible for merging subagent responses into the final answer. You do not get a structured {subagents: [...]} object back; you get one response, and the intermediate agent turns are opaque to your code.
  • Some parameters are silently disabled. reasoning.summary and max_tool_calls are not supported with multi-agent enabled, and the compaction endpoint is unsupported for multi-agent responses. If you rely on reasoning summaries for observability, you lose them the moment you turn this on.

The cost math nobody prints on the marketing page​

At Sol's GA pricing of $5 input / $30 output per million tokens, the arithmetic is unforgiving. From the builder writeups that reverse-engineered real Ultra runs:

  • A task Ultra decomposes into 2 subagents ≈ 2x the output token cost of a single Sol call — because both subagents generate output, and the root then generates the synthesis on top.
  • A task Ultra spawns 5 subagents for ≈ 5x — same reasoning, plus proportionally more input token replay across the tree.
  • The BrowseComp / SEC-Bench charts that show 16-agent configurations are not free lunch: they are a research-grade demonstration, not a default. At 16 concurrent subagents on Sol, you are looking at a mid-two-digit dollar figure per hard query in output tokens alone.

The way to think about it: you are paying for a Monte Carlo of Sol calls plus one synthesis pass on top. Sometimes that buys you enough accuracy to matter. Sometimes it is just a 4x bill for a task a single call would have solved.

What the accuracy actually buys​

The published deltas on the parallelisable evals — the workloads Ultra Mode is designed for — are real but modest:

BenchmarkSol (single)Sol UltraDeltaWhat the eval measures
Terminal-Bench 2.188.8%91.9%+3.1Multi-step command-line planning, tool coordination
BrowseComp87.5%92.2%+4.7Multi-source web research and synthesis
SEC-Bench Pro—74.3%(single-mode number not published)Regulatory doc reasoning across large corpora

Three points about this table:

  • The +3–5 point band is consistent with what parallel sampling has historically bought you on other frontiers (best-of-N, self-consistency). The primitive is genuinely useful; the delta is not a step-change.
  • These are the best case — evaluations chosen to showcase the mode. On sequential tasks (a linear code edit, a single file rewrite, a short chat), Ultra adds synthesis latency and cost without moving accuracy.
  • On the same Terminal-Bench 2.1 chart, Anthropic's Opus 4.8 scored 78.9% — meaning Sol Ultra's lead comes from both the better base model and the multi-agent boost stacked on top. If you migrate to Sol Ultra from Opus, do not attribute the whole gap to the multi-agent primitive.

What Anthropic does instead​

Anthropic has not shipped a symmetric API primitive. The closest analogues each solve a different slice of the same problem:

  • Cowork — a product surface. An agentic desktop workspace where an agent does sustained multi-step work alongside the user. Comparable to Ultra Mode as a feature, but not as an API primitive.
  • Managed Agents and managed-agents memory stores — a hosted agent loop with persistent state and scheduling. Fills the "long-running background agent" slot, not the "spawn 4 in parallel and merge" slot.
  • Claude Code subagents and the subagent fleet limits — a first-class subagent primitive, but scoped to the Claude Code CLI. Documented, spawnable in parallel, and the closest analogue to multi_agent.enabled — with the important difference that you write the coordinator prompt yourself.
  • Building Agents on the Messages API — the DIY path. You fan out N messages.create calls in parallel, you write the synthesis prompt, you handle retries. Same result, more code.

The gap: no Anthropic API surface currently lets you flip a single boolean and have the model itself decide how many subagents to spawn and merge their work. If you want that behavior against Claude, you build it — see Cowork & Agent Teams for the product-side story and Managed Agents for the hosted-loop primitive.

Picking the right primitive per workload​

Guided walkthrough1 of 5
  1. If subtasks can run without waiting on each other's results — audit a repo, research a topic across many sources, refactor N files independently — a fan-out shape earns its cost. If the task is sequential (edit A, then read A's result, then edit B), any multi-agent primitive adds synthesis overhead for no gain.

Four failure modes that turn Ultra into a 4x bill for nothing​

  • Turning it on for sequential tasks. The model still decomposes and synthesises even when the task doesn't parallelise. You pay for coordination overhead on work that never needed it. Rule of thumb: if you can't articulate what the second subagent would be doing while the first runs, don't enable multi-agent.
  • Leaving reasoning-summary observability on your dashboard. reasoning.summary is silently unsupported with multi-agent. If your monitoring depends on it, you'll get empty fields and think the model isn't thinking. Ship a schema change before you flip the flag.
  • Using max_tool_calls as a safety limit. Also silently disabled with multi-agent. The safety story you thought you had — "at most 20 tool calls per request" — is gone. Enforce tool-call ceilings at the tool-adapter layer, not via the request parameter.
  • Assuming max_concurrent_subagents is a cost cap. It caps active subagents at a moment, not total spawned over the request. A single Ultra call can spawn dozens of subagents sequentially and still respect a max_concurrent_subagents: 3 limit. If cost is your ceiling, add a request-level max_output_tokens.

What "native multi-agent" is not​

Two adjacent primitives are often confused with it:

  • Not n > 1 sampling. OpenAI's older n parameter samples multiple completions and returns all of them; you pick one. Multi-agent runs different subagents doing different work and synthesises their outputs. The former is temperature-sampling; the latter is task decomposition.
  • Not batch inference. The batch API processes many independent requests in the background. Multi-agent is many coordinated subagents inside one interactive request. Batch is throughput-oriented, multi-agent is result-oriented.

Where this is heading​

The A2A protocol (see A2A: The Agent-to-Agent Protocol) covers inter-vendor multi-agent. multi_agent.enabled: true covers intra-model multi-agent. The unfilled slot is a cross-vendor primitive — the model on vendor A spawns a subagent on vendor B and merges the result — and there is no public spec for it yet. When it lands, it will land as A2A + a native handoff verb, not as a new API on either side. Watch that space.

Check yourself

0/4
  1. What does max_concurrent_subagents cap on the Responses multi-agent beta?
  2. You enable multi-agent and your monitoring dashboard suddenly shows empty reasoning-summary fields. What happened?
  3. You need parallel subagents that run in different customer accounts across two vendors. Which primitive is correct?
  4. Which of these is a poor candidate for Ultra Mode / multi_agent.enabled?
अभी कोई कार्ड नहीं — अध्ययन शुरू करने के लिए कुछ जोड़ें। 🃏

Sources & further reading​