Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design

Multi-agent

Lass ein Modell in einer Anfrage an die Responses API Subagenten starten, die parallel an klar umrissenen Aufgaben arbeiten.

Überblick

Mit Multi-agent kann ein Modell Subagenten starten, ihre parallele Arbeit koordinieren und die Ergebnisse zu einer abschließenden Antwort zusammenführen. Das eignet sich besonders für Anwendungen mit komplexen Aufgaben, die sich parallel bearbeiten lassen, etwa wenn du eine Codebasis untersuchen, dokumentieren oder Funktionen implementieren möchtest.

Multi-agent ist als Beta-Funktion für GPT-6.1 Sol und alle Modelle der GPT-5.6-Reihe verfügbar. Prüfe die Angaben auf der Modellseite, bevor du Multi-agent in deiner Anwendung aktivierst.

Wann sich Multi-agent eignet

Viele Aufgaben lassen sich in unabhängige Teilaufgaben aufteilen. Ein einzelner Agent würde sie nacheinander bearbeiten, mehrere Agenten können sie parallel erledigen. Mit Multi-agent kann ein Hauptagent solche Aufgaben an mehrere Subagenten delegieren, die gleichzeitig daran arbeiten. Das kann mehrere Vorteile haben:

  • Parallele Ausführung. Unabhängige Recherche-, Analyse- oder Implementierungsaufgaben können gleichzeitig laufen. Dadurch lässt sich die Bearbeitungszeit verkürzen.
  • Eigener Kontext. Jeder Subagent erhält eine klar abgegrenzte Aufgabe und arbeitet mit seinem eigenen Kontext. So beeinflussen sich voneinander unabhängige Aufgaben weniger, was die Leistung verbessert.
  • Koordination durch das Modell. Der Hauptagent kann Subagenten erstellen, ihnen zusätzliche Informationen senden, auf Ergebnisse warten und daraus eine abschließende Antwort formulieren. Deine Anwendung muss die Orchestrierung dafür nicht selbst implementieren.

Die Orchestrierung mit Multi-agent eignet sich besonders für Aufgaben, die sich in konkrete, voneinander unabhängige Teilaufgaben gliedern lassen. Beispiele dafür sind:

  • Verschiedene Bereiche einer großen Codebasis untersuchen
  • Mehrere Vorschläge, Dokumente oder Hypothesen vergleichen
  • Parallel in mehreren Quellen recherchieren
  • Voneinander unabhängige Komponenten implementieren oder separate Testsuiten schreiben
  • Verschiedenen möglichen Fehlerursachen parallel nachgehen
  • Mehrere Lösungsansätze gleichzeitig untersuchen

Zusätzliche Subagenten können den Tokenverbrauch erhöhen. Sie bringen unter Umständen weniger, wenn das Reasoning eine feste Abfolge aufeinander aufbauender Schritte erfordert, wenn die Agenten häufig in einen gemeinsamen veränderlichen Zustand schreiben müssen oder wenn bereits ein einzelner langsamer externer Vorgang die Laufzeit bestimmt.

Nutze Multi-agent, wenn … Nutze vorzugsweise einen einzelnen Agenten, wenn …
sich die Arbeit in unabhängige, klar abgegrenzte Aufgaben aufteilen lässt. jeder Schritt unmittelbar vom vorherigen abhängt.
ein eigener Kontext pro Aufgabe hilft, sich auf das Wesentliche zu konzentrieren. die Aufgabe klein genug für einen einzigen kurzen Durchlauf ist.
parallele Untersuchungen die Gesamtdauer verkürzen können. mehrere Agenten um den Zugriff auf dieselbe veränderliche Ressource konkurrieren würden.
der Vergleich unabhängiger Ergebnisse mehr Aspekte der Aufgabe abdeckt. du einen festen, deterministischen Ausführungsgraphen benötigst.

Schnellstart

Die Python- und TypeScript-Beispiele verwenden die Beta-Version des Responses SDK. Verwende für HTTP-Anfragen client.beta.responses und übergib responses_multi_agent=v1 im Argument betas. Übergib bei direkten HTTP-Anfragen und WebSocket-Verbindungen OpenAI-Beta: responses_multi_agent=v1 in den Anfrage- bzw. Verbindungsheadern. Die Schemas der Elemente können sich während der Beta-Phase von Multi-agent ändern.

Aktiviere Multi-agent in deiner Anfrage an die Responses API mit multi_agent.enabled. Wenn multi_agent.enabled auf true gesetzt ist, kann der Hauptagent einen Baum von Subagenten erstellen. Die Subagenten verwenden das Modell und die verfügbaren Tools aus der Anfrage. Die Agenten stimmen sich über grundlegende Aktionen ab, mit denen sie Subagenten starten, Nachrichten senden und auf Ergebnisse warten können (siehe So funktioniert Multi-agent). Der Hauptagent führt die Antworten der Subagenten zusammen und gibt die abschließende Antwort aus.

Einen Pull Request mit Subagenten prüfen
from openai import OpenAI

client = OpenAI()


def review_pull_request(diff: str) -> str:
    response = client.beta.responses.create(
        model="gpt-6.1-sol",
        input=(
            "Review the pull-request diff below with three agents: one for "
            "correctness, one for security, and one for missing tests. "
            "Reconcile duplicate or conflicting findings, then return a "
            "prioritized review with file and line references.\n\n"
            f"<diff>\n{diff}\n</diff>"
        ),
        multi_agent={
            "enabled": True,
            "max_concurrent_subagents": 3,
        },
        betas=["responses_multi_agent=v1"],
    )

    return "".join(
        part.text
        for item in response.output
        if (
            item.type == "message"
            and item.agent is not None
            and item.agent.agent_name == "/root"
            and item.phase == "final_answer"
        )
        for part in item.content
        if part.type == "output_text"
    )

max_concurrent_subagents legt fest, wie viele Subagenten im gesamten Agentenbaum gleichzeitig aktiv sein können. Dabei zählen alle nachgeordneten Agenten auf jeder Ebene, von direkten Subagenten über deren Subagenten bis hin zu tieferen Ebenen. Der Hauptagent zählt nicht mit.

Die API gibt für diese Einstellung keine feste Obergrenze vor. Der Standardwert 3 empfiehlt sich für die meisten Aufgaben. Auch für die Tiefe des Agentenbaums und die Gesamtzahl der während eines Multi-agent-Durchlaufs erstellten Subagenten gibt es keine feste Obergrenze.

Mit einer Developer-Nachricht kannst du genauer vorgeben, wann das Modell des Hauptagenten Subagenten starten soll. Diese Nachricht ergänzt die Anweisungen, die der Hauptagent und die Subagenten automatisch erhalten.

Beispiele für Developer-Nachrichten:

  • „Starte Subagenten nur, wenn die Person, die die Anfrage stellt, ausdrücklich um Subagenten, die Delegation von Aufgaben oder die parallele Arbeit mehrerer Agenten bittet.“
  • „Die proaktive Delegation mit Multi-agent ist aktiviert. Setze Subagenten ein, wenn sich die Bearbeitungszeit durch paralleles Arbeiten deutlich verkürzen oder die Qualität deutlich verbessern lässt.“

So funktioniert Multi-agent

Die Responses API stellt den Modellen des Hauptagenten und der Subagenten gehostete Aktionen zur Orchestrierung sowie Anweisungen für deren Verwendung bereit. Der Hauptagent heißt /root. Die Pfade der neu gestarteten Subagenten bilden die Hierarchie ab, zum Beispiel:

/root
├── /root/researcher
├── /root/reviewer
└── /root/reviewer/tester

Multi-agent begrenzt weder die Gesamtzahl der Subagenten noch die Tiefe des Agentenbaums auf einen festen Wert. Verwende für die meisten Aufgaben bei max_concurrent_subagents den Standardwert 3. Diese Einstellung begrenzt die Anzahl der gleichzeitig aktiven Bearbeitungsrunden von Subagenten im gesamten Baum. Sie gilt für direkte Subagenten ebenso wie für Subagenten auf tieferen Ebenen.

Wenn Multi-agent aktiviert ist, stellt die Responses API sechs gehostete Aktionen für die Zusammenarbeit bereit. Sie können als Elemente vom Typ multi_agent_call erscheinen. Deine Anwendung soll diese Aktionen weder ausführen noch Ergebnisse dafür übermitteln.

Aktion Zweck
spawn_agent Erstellt einen Subagenten und weist ihm seine erste Aufgabe zu.
send_message Stellt eine Nachricht für einen vorhandenen Agenten in die Warteschlange, ohne eine neue Bearbeitungsrunde zu starten.
followup_task Weist einem vorhandenen Agenten außer dem Hauptagenten weitere Arbeit zu und startet seine Bearbeitungsrunde oder setzt sie fort.
wait_agent Wartet auf eine neue Nachricht im Postfach des aufrufenden Agenten.
interrupt_agent Unterbricht die aktive Bearbeitungsrunde eines anderen Agenten, ohne dessen Kontext zu löschen.
list_agents Gibt den aktuellen Agentenbaum, den Status der einzelnen Agenten und für jeden Agenten den Wert von last_task_message zurück.

Aufrufe von Tools, die du selbst definierst, verarbeitest du genauso wie ohne Multi-agent. Jeder Agent im Baum kann einen function_call ausgeben. Deine Anwendung muss den Aufruf ausführen und einen passenden function_call_output übermitteln.

Alle Agenten im Baum haben Zugriff auf die Tools, die für den Modellaufruf in der API-Anfrage konfiguriert sind.

Multi-agent in der Responses API verwenden

HTTP und WebSocket im Leistungsvergleich

HTTP und WebSocket unterstützen dieselben Multi-agent-Funktionen. Für Workflows mit vielen Toolaufrufen oder langer Laufzeit empfiehlt sich WebSocket. Über die dauerhafte Verbindung kann deine Anwendung Funktionsergebnisse zurückgeben, sobald sie vorliegen. Das senkt den Aufwand für die Fortsetzung und verkürzt die Wartezeit der Agenten.

Bei HTTP endet die Antwort, sobald jeder aktive Agent entweder fertig ist oder auf das Ergebnis eines clientseitigen Funktionsaufrufs wartet. Deine Anwendung führt dann alle ausstehenden Funktionsaufrufe aus und übermittelt die Ergebnisse in einer neuen Anfrage an die Responses API. Die wartenden Agenten können anschließend weiterarbeiten.

Bei WebSocket kann deine Anwendung jedes Funktionsergebnis in die laufende Antwort einfügen, sobald es vorliegt. Sie muss nicht warten, bis die Antwort abgeschlossen ist. Der wartende Agent kann seine Arbeit sofort fortsetzen, während andere Agenten weiterarbeiten. Das verkürzt die Wartezeiten bei der Koordination und vermeidet zusätzliche Anfragen und Antworten, wenn Agenten zu unterschiedlichen Zeitpunkten fertig werden oder Tools anfordern.

HTTP kann ausreichen, wenn ein Workflow mehrere gehostete Tools aufruft, etwa für parallele Websuchen, oder mit einer einzigen Anfrage und wenigen Funktionsaufrufen auskommt. Bei den meisten Multi-agent-Workflows dürfte WebSocket die Latenz senken und die Leistung über den gesamten Ablauf verbessern.

Funktionsaufrufe über HTTP ausführen

Ablauf eines Funktionsaufrufs über HTTP zwischen der Anwendung, dem Hauptagenten der Responses API und drei Subagenten.

Funktionsaufrufe über WebSocket ausführen

Ablauf eines Funktionsaufrufs über WebSocket zwischen der Anwendung, dem Hauptagenten der Responses API und drei Subagenten.

HTTP

Für diese Beispiele brauchst du Beta-Versionen der SDKs, die Zugriff auf die Beta-Version der Responses API bieten. Rufe für HTTP-Streaming client.beta.responses.create auf und übergib responses_multi_agent=v1 im Argument betas. Dadurch stehen dir die Beta-Typen und die Autovervollständigung zur Verfügung. Wenn du in Python Typannotationen hinzufügst, importiere die Beta-Typen für Antwortelemente aus openai.types.beta.

Beispiel für clientseitigen Code:

Toolaufrufe beim HTTP-Streaming verarbeiten
from __future__ import annotations

import json
import sys

from openai import OpenAI
from openai.types.beta import BetaResponseOutputItem

client = OpenAI()
ROOT = "/root"
PROPOSALS = {
    "alpha": {"estimated_weeks": 6, "risk": "medium"},
    "beta": {"estimated_weeks": 8, "risk": "low"},
}
tools = [
    {
        "type": "function",
        "name": "get_proposal",
        "description": "Return details for a proposal that the agents should compare.",
        "parameters": {
            "type": "object",
            "properties": {
                "proposal": {
                    "type": "string",
                    "enum": ["alpha", "beta"],
                }
            },
            "required": ["proposal"],
            "additionalProperties": False,
        },
        "strict": True,
    }
]
history = [
    {
        "role": "user",
        "content": (
            "Use two subagents, one for proposal alpha and one for proposal beta. "
            "Have each call get_proposal, then compare their findings."
        ),
    }
]


def agent_name(item: BetaResponseOutputItem) -> str:
    return item.agent.agent_name if item.agent else ROOT


def render_to_user(delta: str) -> None:
    print(delta, end="", flush=True)


def log_subagent_text(agent: str, delta: str) -> None:
    print(f"[{agent}] {delta}", end="", file=sys.stderr, flush=True)


def process_tool_call(name: str, arguments: str) -> str:
    if name != "get_proposal":
        raise ValueError(f"Unknown tool: {name}")
    parsed_arguments = json.loads(arguments)
    return json.dumps(PROPOSALS[parsed_arguments["proposal"]])


while True:
    output_items = []
    pending_calls = []
    item_agents: dict[int, str] = {}

    stream = client.beta.responses.create(
        model="gpt-6.1-sol",
        input=history,
        tools=tools,
        store=False,
        multi_agent={
            "enabled": True,
            "max_concurrent_subagents": 3,
        },
        stream=True,
        betas=["responses_multi_agent=v1"],
    )
    for event in stream:
        if event.type == "response.output_item.added":
            item_agents[event.output_index] = agent_name(event.item)
        elif event.type == "response.output_text.delta":
            agent = item_agents.get(event.output_index, ROOT)
            if agent == ROOT:
                render_to_user(event.delta)
            else:
                log_subagent_text(agent, event.delta)
        elif event.type == "response.output_item.done":
            output_items.append(event.item)
            if event.item.type == "function_call":
                # Handle function calls from both the root agent and subagents.
                pending_calls.append(event.item)
        elif event.type == "response.completed":
            print(f"\nUsage: {event.response.usage}", file=sys.stderr)
            break
        elif event.type in {
            "error",
            "response.failed",
            "response.incomplete",
        }:
            raise RuntimeError(event)

    history.extend(output_items)

    for call in pending_calls:
        history.append(
            {
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": process_tool_call(call.name, call.arguments),
            }
        )

    if not pending_calls:
        break

Wenn ein oder mehrere Agenten von dir definierte Funktionen aufrufen, führe alle ausstehenden Aufrufe aus und erstelle eine Anfrage, die ihre Ergebnisse enthält und die Verarbeitung fortsetzt.

WebSocket

Ruft ein Agent im WebSocket-Modus eine von dir definierte Funktion auf, führe sie in deiner Anwendung aus und sende ihr Ergebnis mit einem response.inject-Ereignis an die laufende Antwort. Der wartende Agent kann dann weiterarbeiten, ohne auf den Abschluss der gesamten Multi-agent-Antwort warten zu müssen.

{
  "type": "response.inject",
  "response_id": "resp_123",
  "input": [
    {
      "type": "function_call_output",
      "call_id": "call_123",
      "output": "{\"temperature\":72}"
    }
  ]
}

Auf eine gültige response.inject-Anfrage antwortet der Server mit einem von zwei Ereignissen:

  • response.inject.created: Der Server hat die Eingabe geprüft und zum Einfügen angenommen.
  • response.inject.failed: Der Server hat die Eingabe nicht eingefügt. Prüfe error.code.
{
  "type": "response.inject.created",
  "sequence_number": 42,
  "response_id": "resp_123"
}
{
  "type": "response.inject.failed",
  "sequence_number": 43,
  "response_id": "resp_123",
  "input": [
    {
      "type": "function_call_output",
      "call_id": "call_123",
      "output": "{\"temperature\":72}"
    }
  ],
  "error": {
    "code": "response_already_completed",
    "message": "Response 'resp_123' has already completed."
  }
}

Entspricht eine Anfrage nicht dem Schema für response.inject, sendet der Server einen allgemeinen Fehler mit dem Statuscode 400 und schließt die WebSocket-Verbindung. Korrigiere die Anfrage und öffne eine neue WebSocket-Verbindung, bevor du ein weiteres Ereignis sendest.

Im Python-Beta-SDK ist der WebSocket-Modus über client.beta.responses.connect verfügbar, im TypeScript-Beta-SDK über ResponsesWS. Übergib OpenAI-Beta: responses_multi_agent=v1 in den Verbindungsheadern. Anders als beim HTTP-Streaming unterstützen die WebSocket-Konnektoren das Argument betas noch nicht.

Speichere die Antwort-ID aus dem response.created-Ereignis und gib sie in jedem response.inject-Ereignis an, das du für diese Antwort sendest. Nachdem du ein Element zum Einfügen gesendet hast, lies weiter Ereignisse aus der WebSocket-Verbindung, bis die Antwort abgeschlossen ist und du für jeden Einfügeversuch entweder ein response.inject.created- oder ein response.inject.failed-Ereignis erhalten hast.

Toolausgaben über WebSocket in die laufende Antwort einfügen
from __future__ import annotations

import json

from openai import OpenAI

client = OpenAI()
PROPOSALS = {
    "alpha": {"estimated_weeks": 6, "risk": "medium"},
    "beta": {"estimated_weeks": 8, "risk": "low"},
}
tools = [
    {
        "type": "function",
        "name": "get_proposal",
        "description": "Return details for a proposal that the agents should compare.",
        "parameters": {
            "type": "object",
            "properties": {
                "proposal": {
                    "type": "string",
                    "enum": ["alpha", "beta"],
                }
            },
            "required": ["proposal"],
            "additionalProperties": False,
        },
        "strict": True,
    }
]


def process_tool_call(name: str, arguments: str) -> str:
    if name != "get_proposal":
        raise ValueError(f"Unknown tool: {name}")
    parsed_arguments = json.loads(arguments)
    return json.dumps(PROPOSALS[parsed_arguments["proposal"]])


def run_multi_agent(connection):
    previous_response_id: str | None = None
    pending_input: list[dict[str, object]] = [{"role": "user", "content": input()}]

    while pending_input:
        request = {
            "type": "response.create",
            "model": "gpt-6.1-sol",
            "store": True,
            "multi_agent": {"enabled": True},
            "tools": tools,
            "input": pending_input,
        }
        if previous_response_id is not None:
            request["previous_response_id"] = previous_response_id

        connection.send(request)

        next_input: list[dict[str, object]] = []
        completed_response = None
        response_id: str | None = None
        pending_injections = 0

        for event in connection:
            event_type = event.type

            if event_type == "response.created":
                response_id = event.response.id

            elif event_type == "response.output_item.done":
                item = event.item

                if item.type == "function_call":
                    if response_id is None:
                        raise RuntimeError(
                            "Received a function call before response.created"
                        )

                    output = {
                        "type": "function_call_output",
                        "call_id": item.call_id,
                        "output": process_tool_call(item.name, item.arguments),
                    }
                    pending_injections += 1

                    connection.send(
                        {
                            "type": "response.inject",
                            "response_id": response_id,
                            "input": [output],
                        }
                    )

            elif event_type == "response.inject.created":
                pending_injections -= 1

            elif event_type == "response.inject.failed":
                pending_injections -= 1

                if event.error.code != "response_already_completed":
                    raise RuntimeError(event.error)

                next_input.extend(item.model_dump(mode="json") for item in event.input)

            elif event_type == "response.completed":
                completed_response = event.response

            elif event_type in {
                "error",
                "response.failed",
                "response.incomplete",
            }:
                raise RuntimeError(event)

            if completed_response is not None and pending_injections == 0:
                break

        if completed_response is None:
            raise RuntimeError("Connection ended before response.completed")
        if pending_injections:
            raise RuntimeError("Connection ended with unacknowledged tool results")

        if not next_input:
            return completed_response

        previous_response_id = completed_response.id
        pending_input = next_input


with client.beta.responses.connect(
    extra_headers={"OpenAI-Beta": "responses_multi_agent=v1"},
) as connection:
    response = run_multi_agent(connection)
    print(
        "".join(
            part.text
            for item in response.output
            if (
                item.type == "message"
                and item.agent is not None
                and item.agent.agent_name == "/root"
                and item.phase == "final_answer"
            )
            for part in item.content
            if part.type == "output_text"
        )
    )

Lies nach dem Senden eines response.inject-Ereignisses weiter aus der WebSocket-Verbindung und verarbeite die Rückmeldung:

  • response.inject.created: Der Server hat das Funktionsergebnis zur laufenden Antwort hinzugefügt. Lies weiter die Ereignisse für diese Antwort.
  • response.inject.failed mit response_already_completed: Die Antwort war bereits abgeschlossen, bevor der Server das Funktionsergebnis hinzufügen konnte. Übernimm den Wert von input aus dem Fehlerereignis und sende ihn in einer neuen response.create-Anfrage, die an die abgeschlossene Antwort anknüpft.
  • response.inject.failed mit response_not_found: Der Server konnte die Antwort mit der angegebenen response_id nicht finden. Prüfe, ob du die ID aus response.created verwendest.

Ein einzelner Multi-agent-Durchlauf kann sich über mehrere Anfragen an die Responses API erstrecken. Ruft ein Agent über HTTP eine von dir definierte Funktion auf, führt deine Anwendung sie aus und übermittelt ihr Ergebnis in einem neuen response.create-Aufruf. Bei WebSocket fügt deine Anwendung das Funktionsergebnis direkt in die laufende Antwort ein.

Neue Ausgabeelemente für Multi-agent

Multi-agent-Antworten können drei zusätzliche Typen von Ausgabeelementen enthalten:

  • multi_agent_call: Protokolliert eine gehostete Multi-agent-Aktion, zum Beispiel spawn_agent.
  • multi_agent_call_output: Enthält das Ergebnis einer ausgeführten gehosteten Aktion.
  • agent_message: Übermittelt eine verschlüsselte Nachricht von einem Agenten an einen anderen.

Das Feld call_id verknüpft jeden multi_agent_call mit dem zugehörigen multi_agent_call_output.

Jedes Element enthält außerdem das Attribut agent. Bei einer agent_message gibt agent.agent_name den empfangenden Agenten an. Anhand von author und recipient kannst du nachvollziehen, wer die Nachricht an wen gesendet hat.

Wenn deine Anwendung einen multi_agent_call empfängt, führe ihn nicht als Funktionsaufruf aus und sende kein Ergebnis zurück. Die Responses API führt die gehostete Aktion aus und gibt den zugehörigen multi_agent_call_output zurück. Bewahre beide Elemente auf, wenn deine Anwendung sie benötigt, um den Ablauf erneut wiederzugeben oder nachzuverfolgen.

[
  {
    "type": "multi_agent_call",
    "id": "mac_123",
    "call_id": "call_spawn_a",
    "action": "spawn_agent",
    "arguments": "{\"task_name\":\"agent_a\",\"fork_turns\":\"all\",\"message\":\"enc_...\"}",
    "agent": { "agent_name": "/root" }
  },
  {
    "type": "multi_agent_call_output",
    "id": "maco_123",
    "call_id": "call_spawn_a",
    "action": "spawn_agent",
    "output": [
      {
        "type": "output_text",
        "text": "{\"task_name\":\"/root/agent_a\"}",
        "annotations": [],
        "logprobs": []
      }
    ],
    "agent": { "agent_name": "/root" }
  },
  {
    "type": "agent_message",
    "id": "amsg_123",
    "author": "/root/agent_a",
    "recipient": "/root",
    "content": [
      {
        "type": "encrypted_content",
        "encrypted_content": "enc_..."
      }
    ],
    "agent": { "agent_name": "/root" }
  }
]

SSE-Ereignisse, die einem Agenten zugeordnet sind, enthalten auf oberster Ebene das Attribut agent. Bei einem agent_message-Ereignis gibt agent.agent_name den empfangenden Agenten an. Ereignisse im Lebenszyklus einer Antwort wie response.created und response.completed beziehen sich auf die gesamte Antwort. Daher enthalten sie kein agent-Attribut.

{
  "type": "response.output_item.done",
  "agent": { "agent_name": "/root" },
  "item": {
    "type": "agent_message",
    "id": "amsg_123",
    "author": "/root/agent_a",
    "recipient": "/root",
    "content": [
      {
        "type": "encrypted_content",
        "encrypted_content": "enc_..."
      }
    ],
    "agent": { "agent_name": "/root" }
  }
}

Einschränkungen

  1. Kontextverdichtung:
    1. Der Endpunkt /responses/compact wird bei aktiviertem Multi-agent nicht unterstützt.
    2. Wenn multi_agent.enabled auf true gesetzt ist, aktiviert die API automatisch die serverseitige Kontextverdichtung, auch wenn die Anfrage keine Einstellung für context_management enthält. Die API verdichtet den Kontext des Hauptagenten und jedes Subagenten separat. So behält jeder Agent seinen eigenen Kontext. Du kannst compact_threshold weiterhin überschreiben, indem du in der Anfrage context_management.compact_threshold explizit setzt.
  2. reasoning.summary wird bei aktiviertem Multi-agent nicht unterstützt.
  3. max_tool_calls wird bei aktiviertem Multi-agent nicht unterstützt.
  4. max_concurrent_subagents hat den empfohlenen Standardwert 3.

Hinweise zu Prompts

Wenn Multi-agent aktiviert ist, fügen unsere Systeme die folgenden Anweisungen für den Hauptagenten und die Subagenten automatisch als neue Developer-Nachricht hinzu. Du kannst diese Anweisungen weder bearbeiten noch entfernen. Formuliere deine eigenen Developer-Anweisungen so, dass sie die automatisch hinzugefügten Anweisungen ergänzen.

Hauptagent

You are `/root`, the primary agent in a team of agents collaborating to fulfill the user's goals.

At the start of your turn, you are the active agent.
You can spawn sub-agents to handle subtasks, and those sub-agents can spawn their own sub-agents.
All agents in the team, including the agents that you can assign tasks to, are equally intelligent and capable, and have access to the same set of tools.

You can use `spawn_agent` to create a new agent, `followup_task` to give an existing agent a new task and trigger a turn, and `send_message` to pass a message to a running agent without triggering a turn.
Child agents can also spawn their own sub-agents.
You can decide how much context you want to propagate to your sub-agents with the `fork_turns` parameter.

You will receive messages in the form:
```
Message Type: MESSAGE | FINAL_ANSWER
Task name: <recipient>
Sender: <author>
Payload:
<payload text>
```
They may be addressed as to=/root

There are {max_concurrent_subagents + 1} available concurrency slots, meaning that up to {max_concurrent_subagents + 1} agents can be active at once, including you.

Subagent

You are an agent in a team of agents collaborating to complete a task.

You can spawn sub-agents to handle subtasks, and those sub-agents can spawn their own sub-agents. All agents in the team, including the agents that you can assign tasks to, are equally intelligent and capable, and have access to the same set of tools.

You can use `spawn_agent` to create a new agent, `followup_task` to give an existing agent a new task and trigger a turn, and `send_message` to pass a message to a running agent.
Child agents can also spawn their own sub-agents.

When you provide a response in the final channel, that content is immediately delivered back to your parent agent.

You will receive messages in the form:
```
Message Type: NEW_TASK | MESSAGE | FINAL_ANSWER
Task name: <recipient>
Sender: <author>
Payload:
<payload text>
```
You may also see them addressed as to=/root/..., which indicates your identity is /root/...

There are {max_concurrent_subagents + 1} available concurrency slots, meaning that up to {max_concurrent_subagents + 1} agents can be active at once, including you.

Weiterführende Leitfäden