Loading...
    • Costruisci
    • Admin
    • Modelli e prezzi
    • Client SDK
    • Riferimento API
    Search...
    ⌘K
    Primi passi
    Introduzione a ClaudeAvvio rapido
    Costruire con Claude
    Panoramica delle funzionalitàUtilizzo delle Messages APIGestione dei motivi di arresto
    Capacità del modello
    Ragionamento estesoRagionamento adattivoImpegnoModalità rapida (beta: anteprima di ricerca)Output strutturatiCitazioniMessaggi in streamingElaborazione batchRisultati di ricercaRifiuti in streamingSupporto multilingueEmbeddings
    Strumenti
    PanoramicaCome funziona l'uso degli strumentiStrumento di ricerca webStrumento di recupero webStrumento di esecuzione del codiceStrumento di memoriaStrumento BashStrumento di utilizzo del computerStrumento editor di testo
    Infrastruttura degli strumenti
    Ricerca strumentiChiamata programmatica degli strumentiStreaming granulare degli strumenti
    Gestione del contesto
    Finestre di contestoCompattazioneModifica del contestoCaching dei promptConteggio dei token
    Lavorare con i file
    Files APISupporto PDFImmagini e visione
    Skills
    PanoramicaAvvio rapidoBest practiceSkills per l'impresaSkills nell'API
    MCP
    Server MCP remotiConnettore MCP
    Prompt engineering
    PanoramicaBest practice per i promptStrumenti di prompting in Console
    Testa e valuta
    Definisci il successo e crea valutazioniUtilizzo dello strumento di valutazione in ConsoleRiduzione della latenza
    Rafforzare i guardrail
    Ridurre le allucinazioniAumentare la coerenza dell'outputMitigare i jailbreakRidurre la perdita di prompt
    Risorse
    Glossario
    Note di rilascio
    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
    Orchestrazione avanzata

    Sessioni multiagente

    Coordina più agenti all'interno di una singola sessione.

    Was this page helpful?

    • Come funziona
    • Cosa delegare
    • Dichiarare gli agenti chiamabili
    • Thread di sessione
    • Tipi di eventi multiagente
    • Permessi degli strumenti e strumenti personalizzati nei thread

    Multiagente è una funzionalità in anteprima di ricerca. Richiedi l'accesso per provarla.

    L'orchestrazione multi-agente consente a un agente di coordinarsi con altri per completare lavori complessi. Gli agenti possono operare in parallelo con il proprio contesto isolato, il che contribuisce a migliorare la qualità dell'output e il tempo di completamento.

    Tutte le richieste API Managed Agents richiedono l'intestazione beta managed-agents-2026-04-01. Per le funzionalità in anteprima di ricerca è necessaria un'ulteriore intestazione beta. L'SDK imposta automaticamente queste intestazioni beta.

    Come funziona

    Tutti gli agenti condividono lo stesso container e filesystem, ma ogni agente viene eseguito nel proprio thread di sessione, un flusso di eventi con contesto isolato e la propria cronologia delle conversazioni. Il coordinatore riporta l'attività nel thread primario (che coincide con il flusso di eventi a livello di sessione); i thread aggiuntivi vengono generati in fase di esecuzione quando il coordinatore decide di delegare.

    I thread sono persistenti: il coordinatore può inviare un messaggio di follow-up a un agente chiamato in precedenza, e quell'agente conserva tutto ciò che è avvenuto nei turni precedenti.

    Ogni agente utilizza la propria configurazione (modello, prompt di sistema, strumenti, server MCP e competenze) come definita al momento della creazione dell'agente. Strumenti e contesto non sono condivisi.

    Cosa delegare

    Le sessioni multiagente funzionano meglio quando ci sono più attività ben definite e specializzate all'interno di un obiettivo complessivo:

    • Revisione del codice: Un agente revisore con un prompt di sistema mirato e strumenti di sola lettura.
    • Generazione di test: Un agente di test che scrive ed esegue test senza toccare il codice di produzione.
    • Ricerca: Un agente di ricerca con strumenti web che riassume i risultati al coordinatore.

    Dichiarare gli agenti chiamabili

    Quando si definisce il proprio agente, elencare gli ID aggiuntivi degli agenti che è autorizzato a chiamare:

    Ogni voce in callable_agents deve essere l'ID di un agente esistente. È supportato un solo livello di delega: il coordinatore può chiamare altri agenti, ma quegli agenti non possono chiamare agenti propri.

    Quindi creare una sessione che faccia riferimento all'orchestratore:

    Gli agenti chiamabili vengono risolti dalla configurazione dell'orchestratore. Non è necessario fare riferimento a loro durante la creazione della sessione.

    Thread di sessione

    Il flusso di eventi a livello di sessione (/v1/sessions/:id/stream) è considerato il thread primario, che contiene una vista condensata di tutta l'attività su tutti i thread. Non si vedranno le tracce individuali degli agenti chiamati, ma si vedrà l'inizio e la fine del loro lavoro. I thread di sessione sono dove si approfondisce il ragionamento e le chiamate agli strumenti di un agente specifico.

    Lo stato della sessione è anche un'aggregazione di tutta l'attività degli agenti; se almeno un thread è running, anche lo stato complessivo della sessione sarà running.

    Elencare tutti i thread in una sessione come segue:

    Trasmettere in streaming gli eventi da un thread specifico:

    Elencare gli eventi passati per un thread:

    Tipi di eventi multiagente

    Questi eventi mostrano l'attività multiagente sul flusso di sessione di primo livello.

    TipoDescrizione
    session.thread_createdIl coordinatore ha generato un nuovo thread. Include session_thread_id e model.
    session.thread_idleUn thread agente ha terminato il lavoro corrente.
    agent.thread_message_sentUn agente ha inviato un messaggio a un altro thread. Include to_thread_id e content.
    agent.thread_message_receivedUn agente ha ricevuto un messaggio da un altro thread. Include from_thread_id e content.

    Permessi degli strumenti e strumenti personalizzati nei thread

    Quando un thread callable_agent ha bisogno di qualcosa dal client (permesso per eseguire uno strumento always_ask, o il risultato di uno strumento personalizzato) la richiesta appare nel flusso di sessione con un campo session_thread_id. Includere lo stesso session_thread_id quando si pubblica la risposta in modo che la piattaforma la instradi al thread in attesa.

    • session_thread_id è presente: l'evento ha avuto origine in un thread di subagente. Ripeterlo nella risposta.
    • session_thread_id è assente: l'evento proviene dal thread primario. Rispondere senza il campo.
    • Abbinare tool_use_id per associare richieste e risposte.

    L'esempio seguente estende il gestore di conferma degli strumenti per instradare le risposte. Lo stesso schema si applica a 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")