The headline feature nobody quite believes until they run it: with GPT-5.6, you can hand the Responses API a task, and it will spin up a swarm of subagents that run concurrently, then merge their work into one answer — inside a single API call. No orchestration loop. No state machine. No graph. You send one request; OpenAI runs the fan-out and the synthesis and hands you a result.

For a certain kind of task, that is genuinely magic. For another kind, it is the most expensive shortcut you can take. Here's the line between them.

What "built-in" actually gives you#

Multi-agent is a beta on all GPT-5.6 models. Mechanically, a root agent delegates to subagents, waits for them, and synthesizes a final answer — and, per OpenAI's docs, it does this "without requiring your application to implement orchestration." The API even exposes six hosted collaboration actions the models use to talk to each other; they surface in the output as multi_agent_call items, and — this is the important footnote — your application must not execute them or submit outputs for them. They are internal plumbing, informational to you.

from openai import OpenAI
client = OpenAI()

res = client.responses.create(
    model="gpt-5.6-terra",
    input="Audit these three vendor contracts for auto-renewal clauses and summarize the risk.",
    reasoning={"effort": "ultra"},          # Ultra: ~4 agents in parallel by default
    max_concurrent_subagents=3,             # the default; fits most tasks
    tools=[{"type": "web_search"}, {"type": "code_interpreter"}],
)
print(res.output_text)

That's the whole program. Three subagents each take a contract, run concurrently, and the root synthesizes one risk summary. The default max_concurrent_subagents is 3; Ultra mode coordinates four in parallel by default, trading more tokens for stronger, faster results. Push past ~8–10 concurrent sub-tasks and OpenAI's own guidance is to chunk into phases rather than widen the swarm — a wide fan-out spends tokens faster than it buys quality.

The pitch is real: a task that would have been a hundred lines of orchestration is now one request. The question is what you gave up to get there.

What it takes away#

Everything you'd want to see or steer. Built-in multi-agent is a black box with one input and one output:

When to roll your own#

The moment any of those four things matters, you want an external orchestrator — LangGraph, the Claude Agent SDK, or similar. Yes, you write the graph. In exchange you get model choice per node (mix a cheap model for grunt work with a frontier model for judgment), durable state and resume, native approval gates between nodes, real traces, and portability — the pipeline isn't welded to one vendor's API.

That tradeoff maps almost one-to-one onto the same decision at the tool layer. GPT-5.6's programmatic tool calling hides the tool orchestration in a sandbox; built-in multi-agent hides the agent orchestration in the API. Both are the vendor saying "let us run the loop." Both are excellent when you don't need to watch the loop, and a liability when you do. The Responses API is also where this lives at all — if you're still on Chat Completions or Assistants, that migration comes first.

The rule#

Use built-in multi-agent for what it's for: fast, self-contained fan-outs you don't need to see inside. Prototyping. A research task where "good answer, one call" beats "auditable pipeline." A batch job where a re-run is cheap and no human needs to intervene. There, writing your own graph is pure ceremony.

Reach for your own orchestrator the moment the pipeline becomes something you run in production and have to answer for — where a wrong answer needs a trace, a long run needs a checkpoint, a sensitive step needs a human, and the finance team needs you off single-vendor pricing. The built-in swarm is a wonderful way to start. It is a poor place to be standing when something breaks at 2 a.m. and the box won't open.