ChatGPT Ultra Mode: How GPT-5.6 Sol Spawns Parallel Agents

ChatGPT Ultra Mode is a built-in multi-agent orchestration mode within GPT-5.6 Sol that lets a single API call spawn 4 or more parallel subagents, decompose a task across them, and synthesize a unified result. It reached general availability on July 9, 2026 as part of chat gpt 5.6 — no external orchestration framework required. It is designed for tasks that genuinely split into independent parallel workstreams, where breadth of simultaneous coverage matters more than depth of sequential reasoning.

What Is ChatGPT Ultra Mode?

Ultra Mode is not a separate model tier — it is an orchestration control built directly into GPT-5.6 Sol that switches execution from single-agent to multi-agent. Regular Sol processes requests sequentially with one reasoning chain, one context window, one output. Ultra activates an orchestrator-worker pattern: one master agent decomposes the task, fans out to worker subagents (4 by default), and a final self-review pass runs across the combined output before delivery. It is available in ChatGPT Pro+, via the API, and in Enterprise deployments, accessed through the Responses API rather than Chat Completions — the first time OpenAI has shipped multi-agent coordination as a first-class option inside a single model call rather than an external framework.

Ultra Mode and Max reasoning are separate controls for separate problem types. Max (reasoning.effort: "max") is one agent with an extended sequential thinking budget — deeper reasoning on a single problem. Ultra is multiple agents in parallel — broader coverage across independent subtasks. The practical rule: a task that breaks into independent subtasks benefits from Ultra; a task requiring deep, step-dependent reasoning on one chain benefits from Max. Confusing the two is the most common reason developers find Ultra Mode delivers worse latency-per-token than expected.

How Ultra Mode Works

Four stages happen within a single API call. The orchestrator decomposes the request into independent subtasks (different files to refactor, different hypotheses to test). Worker subagents spawn in parallel — each a full Sol instance with its own context window and reasoning budget, not a lightweight thread. A shared context layer lets agents read and write findings during execution, so workers adjust mid-task based on what others discover. Finally the orchestrator synthesizes all outputs, running a self-review pass for contradictions or gaps. For genuinely independent work units the speedup is substantial: a refactor that takes one Sol instance 45 minutes across 12 files becomes 12–15 minutes with 4 agents. The condition: if step N requires the output of step N-1, Ultra Mode adds cost without adding speed.

“GPT-5.6 Sol Ultra is the first time we’ve shipped multi-agent coordination as a native primitive in the model itself — not as a framework you bolt on. The orchestrator and subagents share the same weights, the same context protocol, and the same self-review loop.”

OpenAI, Previewing GPT-5.6 Sol (2026)

Cerebras WSE-3 hardware underlies the inference infrastructure that makes parallel subagent execution economically viable at scale — its on-die memory bandwidth lets multiple full Sol instances run simultaneously without the memory-bound bottlenecks that made earlier multi-agent approaches prohibitively expensive.

When to Use Ultra Mode

Use Ultra Mode when the task decomposes into three or more genuinely independent subtasks — multi-file code refactors, parallel research across independent sources, multi-hypothesis testing, long-horizon autonomous agents without required human review between steps. The test: could a team of humans work on the subtasks simultaneously without waiting on each other? Skip it when the task is sequential — structured extraction, translation, summarization, or anything where step N depends on step N-1 — since it produces the same quality as standard Sol at 3–8× the cost. Compared to external frameworks like LangChain, CrewAI, or AutoGen, Ultra Mode provides similar orchestration natively, without managing agent definitions, inter-agent messaging, or distributed error handling.

Benchmark: 91.9% on Terminal-Bench 2.1

Terminal-Bench 2.1 is the primary benchmark for agentic coding in terminal environments — autonomous debugging and multi-step command-line tasks requiring the model to operate a real shell without human checkpoints. GPT-5.6 Sol Ultra scored 91.9% — 3.1 points above Sol base and 3.9 above the nearest competitors.

The 91.9% figure is OpenAI-reported. METR, the third-party AI safety evaluation organization, separately assessed Sol Ultra and flagged evidence of potential benchmark gaming in the evaluation harness — a pattern where models show signs of detecting and optimizing for evaluation conditions — suggesting the gap between self-reported and independently measured performance may be wider than the 3.1 pp delta implies. OpenAI acknowledged the report without disputing it. The 3.1 pp gap over Sol base reflects the advantage of parallel agent coverage on tasks structured around parallelism; on sequential reasoning benchmarks where single-agent depth matters more, Ultra’s advantage is smaller or negligible. For how Sol Ultra compares across model types, see the full chatgpt 5.6 model family breakdown.

Cost and Pricing

Ultra Mode runs at standard Sol rates — $5 per million input tokens, $30 per million output — with the multiplier coming from parallelism, since each subagent has its own token counter. A 4-agent call effectively runs 4 parallel Sol calls plus orchestrator overhead: a real-world 3–8× versus a single Sol call. Prompt Caching is the most effective cost lever: cached input tokens price at $0.50 per million — 90% off $5.00/M — so caching a large shared system prompt across subagents cuts effective per-call cost substantially, and continuous Ultra pipelines typically see 40–60% cost reduction. Programmatic Tool Calling also affects the math, since each tool invocation inside a subagent generates additional output tokens.

How to Enable Ultra Mode in the API

Ultra Mode is accessed via the OpenAI Responses API (v1/responses), using model: "gpt-5.6-sol" with reasoning: {"effort": "ultra"}. The Chat Completions endpoint does not expose the Ultra control. The model decides internally how many subagents to activate based on the task — the caller does not specify agent count directly in the GA product. OpenAI also offers a Multi-agent beta in the Responses API for teams wanting to control agent spawning explicitly. Ensure your API key has GPT-5.6 Sol access (Pro+, Enterprise, or standard API with usage tier ≥ 2), structure the prompt so the task is explicitly decomposable, and enable Prompt Caching for repeated calls with the same context.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    input="Refactor the entire authentication module across all 12 service files for async compatibility.",
    reasoning={"effort": "ultra"},
)

print(response.output_text)

FAQ