Loading...
    • Erstellen
    • Admin
    • Modelle & Preise
    • Client SDKs
    • API-Referenz
    Search...
    ⌘K
    Erste Schritte
    Einführung in ClaudeSchnellstart
    Entwickeln mit Claude
    FunktionsübersichtVerwendung der Messages APIStoppgründe behandeln
    Modellfähigkeiten
    Erweitertes DenkenAdaptives DenkenAufwandSchnellmodus (Beta: Forschungsvorschau)Strukturierte AusgabenZitateStreaming-NachrichtenStapelverarbeitungSuchergebnisseStreaming-AblehnungenMehrsprachige UnterstützungEmbeddings
    Tools
    ÜbersichtWie Tool-Nutzung funktioniertWeb-SuchtoolWeb-AbruftoolCode-AusführungstoolSpeichertoolBash-ToolComputer-Use-ToolTexteditor-Tool
    Tool-Infrastruktur
    Tool-SucheProgrammatisches Tool-AufrufenFeingranulares Tool-Streaming
    Kontextverwaltung
    KontextfensterKomprimierungKontextbearbeitungPrompt-CachingToken-Zählung
    Mit Dateien arbeiten
    Files APIPDF-UnterstützungBilder und Vision
    Skills
    ÜbersichtSchnellstartBest PracticesSkills für UnternehmenSkills in der API
    MCP
    Remote-MCP-ServerMCP-Connector
    Prompt-Engineering
    ÜbersichtBest Practices für PromptsConsole-Prompting-Tools
    Testen und Evaluieren
    Erfolg definieren und Evaluierungen erstellenDas Evaluierungstool in der Console verwendenLatenz reduzieren
    Leitplanken stärken
    Halluzinationen reduzierenAusgabekonsistenz erhöhenJailbreaks abmildernPrompt-Lecks reduzieren
    Ressourcen
    Glossar
    Versionshinweise
    Claude Platform
    Console
    Log in
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...

    Solutions

    • AI agents
    • Code modernization
    • Coding
    • Customer support
    • Education
    • Financial services
    • Government
    • Life sciences

    Partners

    • Amazon Bedrock
    • Google Cloud's Vertex AI

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Company

    • Anthropic
    • Careers
    • Economic Futures
    • Research
    • News
    • Responsible Scaling Policy
    • Security and compliance
    • Transparency

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Help and security

    • Availability
    • Status
    • Support
    • Discord

    Terms and policies

    • Privacy policy
    • Responsible disclosure policy
    • Terms of service: Commercial
    • Terms of service: Consumer
    • Usage policy
    Erweiterte Orchestrierung

    Multiagent-Sitzungen

    Koordinieren Sie mehrere Agenten innerhalb einer einzigen Sitzung.

    Was this page helpful?

    • Funktionsweise
    • Was delegiert werden sollte
    • Aufrufbare Agenten deklarieren
    • Sitzungs-Threads
    • Multiagent-Ereignistypen
    • Tool-Berechtigungen und benutzerdefinierte Tools in Threads

    Multiagent ist eine Research-Preview-Funktion. Zugang anfordern, um sie auszuprobieren.

    Multi-Agenten-Orchestrierung ermöglicht es einem Agenten, mit anderen zu koordinieren, um komplexe Aufgaben zu erledigen. Agenten können parallel mit ihrem eigenen isolierten Kontext arbeiten, was die Ausgabequalität verbessert und die Zeit bis zur Fertigstellung verkürzt.

    Alle Managed Agents API-Anfragen erfordern den Beta-Header managed-agents-2026-04-01. Für Research-Preview-Funktionen wird ein zusätzlicher Beta-Header benötigt. Das SDK setzt diese Beta-Header automatisch.

    Funktionsweise

    Alle Agenten teilen denselben Container und dasselbe Dateisystem, aber jeder Agent läuft in seinem eigenen Sitzungs-Thread, einem kontextisolierten Ereignisstrom mit seiner eigenen Konversationshistorie. Der Koordinator meldet Aktivitäten im primären Thread (der dem sitzungsweiten Ereignisstrom entspricht); zusätzliche Threads werden zur Laufzeit erzeugt, wenn der Koordinator beschließt zu delegieren.

    Threads sind persistent: Der Koordinator kann eine Folgenachricht an einen Agenten senden, den er zuvor aufgerufen hat, und dieser Agent behält alles aus seinen vorherigen Runden.

    Jeder Agent verwendet seine eigene Konfiguration (Modell, System-Prompt, Tools, MCP-Server und Skills), wie sie bei der Erstellung des Agenten definiert wurde. Tools und Kontext werden nicht geteilt.

    Was delegiert werden sollte

    Multiagent-Sitzungen funktionieren am besten, wenn es mehrere klar abgegrenzte, spezialisierte Aufgaben in einem übergeordneten Ziel gibt:

    • Code-Review: Ein Reviewer-Agent mit einem fokussierten System-Prompt und schreibgeschützten Tools.
    • Testgenerierung: Ein Test-Agent, der Tests schreibt und ausführt, ohne den Produktionscode zu berühren.
    • Recherche: Ein Such-Agent mit Web-Tools, der Ergebnisse an den Koordinator zurückmeldet.

    Aufrufbare Agenten deklarieren

    Wenn Sie Ihren Agenten definieren, listen Sie zusätzliche IDs von Agenten auf, die er aufrufen darf:

    Jeder Eintrag in callable_agents muss die ID eines vorhandenen Agenten sein. Es wird nur eine Delegierungsebene unterstützt: Der Koordinator kann andere Agenten aufrufen, aber diese Agenten können keine eigenen Agenten aufrufen.

    Erstellen Sie dann eine Sitzung, die auf den Orchestrator verweist:

    Die aufrufbaren Agenten werden aus der Konfiguration des Orchestrators aufgelöst. Sie müssen sie bei der Sitzungserstellung nicht referenzieren.

    Sitzungs-Threads

    Der sitzungsweite Ereignisstrom (/v1/sessions/:id/stream) wird als primärer Thread betrachtet und enthält eine komprimierte Ansicht aller Aktivitäten über alle Threads hinweg. Sie sehen keine individuellen Traces der aufgerufenen Agenten, aber Sie sehen den Beginn und das Ende ihrer Arbeit. Sitzungs-Threads sind der Ort, an dem Sie in die Überlegungen und Tool-Aufrufe eines bestimmten Agenten eintauchen.

    Der Sitzungsstatus ist ebenfalls eine Aggregation aller Agentenaktivitäten; wenn mindestens ein Thread running ist, wird der Gesamtsitzungsstatus ebenfalls running sein.

    Listen Sie alle Threads in einer Sitzung wie folgt auf:

    Ereignisse aus einem bestimmten Thread streamen:

    Vergangene Ereignisse für einen Thread auflisten:

    Multiagent-Ereignistypen

    Diese Ereignisse zeigen Multiagent-Aktivitäten im übergeordneten Sitzungsstrom an.

    TypBeschreibung
    session.thread_createdDer Koordinator hat einen neuen Thread erzeugt. Enthält die session_thread_id und das model.
    session.thread_idleEin Agenten-Thread hat seine aktuelle Arbeit beendet.
    agent.thread_message_sentEin Agent hat eine Nachricht an einen anderen Thread gesendet. Enthält to_thread_id und content.
    agent.thread_message_receivedEin Agent hat eine Nachricht von einem anderen Thread empfangen. Enthält from_thread_id und content.

    Tool-Berechtigungen und benutzerdefinierte Tools in Threads

    Wenn ein callable_agent-Thread etwas von Ihrem Client benötigt (Berechtigung zum Ausführen eines always_ask-Tools oder das Ergebnis eines benutzerdefinierten Tools), erscheint die Anfrage im Sitzungsstrom mit einem session_thread_id-Feld. Geben Sie dieselbe session_thread_id an, wenn Sie Ihre Antwort senden, damit die Plattform sie an den wartenden Thread weiterleitet.

    • session_thread_id ist vorhanden: Das Ereignis stammt aus einem Subagenten-Thread. Geben Sie es in Ihrer Antwort zurück.
    • session_thread_id fehlt: Das Ereignis kam vom primären Thread. Antworten Sie ohne das Feld.
    • Verwenden Sie tool_use_id, um Anfragen mit Antworten zu verknüpfen.

    Das folgende Beispiel erweitert den Tool-Bestätigungs-Handler, um Antworten weiterzuleiten. Dasselbe Muster gilt für user.custom_tool_result.

    orchestrator=$(curl -fsS https://api.anthropic.com/v1/agents \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      -d @- <<EOF
    {
      "name": "Engineering Lead",
      "model": "claude-sonnet-4-6",
      "system": "You coordinate engineering work. Delegate code review to the reviewer agent and test writing to the test agent.",
      "tools": [
        {
          "type": "agent_toolset_20260401"
        }
      ],
      "callable_agents": [
        {"type": "agent", "id": "$REVIEWER_AGENT_ID", "version": $REVIEWER_AGENT_VERSION},
        {"type": "agent", "id": "$TEST_WRITER_AGENT_ID", "version": $TEST_WRITER_AGENT_VERSION}
      ]
    }
    EOF
    )
    session=$(curl -fsS https://api.anthropic.com/v1/sessions \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      -d '{"agent": "'$ORCHESTRATOR_ID'", "environment_id": "'$ENVIRONMENT_ID'"}')
    curl -fsS "https://api.anthropic.com/v1/sessions/$SESSION_ID/threads" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      | jq -r '.data[] | "[\(.agent_name)] \(.status)"'
    curl -fsSN "https://api.anthropic.com/v1/sessions/$SESSION_ID/threads/$THREAD_ID/stream" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" |
      while IFS= read -r line; do
        [[ $line == data:* ]] || continue
        json=${line#data: }
        case $(jq -r '.type' <<<"$json") in
          agent.message)
            printf '%s' "$(jq -j '.content[] | select(.type == "text") | .text' <<<"$json")"
            ;;
          session.thread_idle)
            break
            ;;
        esac
      done
    curl -fsS "https://api.anthropic.com/v1/sessions/$SESSION_ID/threads/$THREAD_ID/events" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      | jq -r '.data[] | "[\(.type)] \(.processed_at)"'
    while IFS= read -r event_id; do
      pending=$(jq -r --arg id "$event_id" '.[$id]' <<<"$events_by_id")
      thread_id=$(jq -r '.session_thread_id // empty' <<<"$pending")
      jq -n --arg id "$event_id" --arg thread "$thread_id" '
        {events: [
          {type: "user.tool_confirmation", tool_use_id: $id, result: "allow"}
          + (if $thread != "" then {session_thread_id: $thread} else {} end)
        ]}' |
        curl -fsS "https://api.anthropic.com/v1/sessions/$SESSION_ID/events?beta=true" \
          -H "x-api-key: $ANTHROPIC_API_KEY" \
          -H "anthropic-version: 2023-06-01" \
          -H "anthropic-beta: managed-agents-2026-04-01" \
          -H "content-type: application/json" \
          -d @-
    done < <(jq -r '.stop_reason.event_ids[]' <<<"$data")