Creazione di agenti: quando integrare i subagent nel ciclo principale dell'agente

Quando si creano agenti in Claude Platform, utilizzare un numero inferiore di subagent a favore di un'esposizione progressiva del contesto e degli strumenti può migliorare la qualità, riducendo al contempo costi e latenza. Di seguito spieghiamo quando e come eseguire la migrazione.

  • ProdottoClaude Platform
  • AuthorDiane Sarkis
  • Data22 ottobre 2026
  • Tempo di lettura22 min
  • Condividi

Se hai creato un agente su Claude Platform che include più subagent, valuta quali potrebbe avere senso integrare nel ciclo principale dell'agente usando il nostro kit di migrazione. Il kit esegue un flusso di lavoro guidato per identificare i tuoi pattern, valutare le alternative e verificare l'approccio migliore. Include una demo che puoi provare su un sistema simulato prima di eseguirlo sul tuo agente.

I subagent, ovvero gli agenti dotati di una propria finestra di contesto, strumenti e istruzioni orchestrati da un coordinatore, sono una componente fondamentale della progettazione degli agenti. Sono efficaci per la verifica, il lavoro in parallelo e l'assegnazione modulare delle autorizzazioni. Li utilizziamo in molti degli agenti che sviluppiamo con Claude Platform, ad esempio nel nostro sistema di ricerca multiagente.

Tuttavia, di recente il team di IA applicata ha individuato una tendenza ricorrente tra le distribuzioni di agenti aziendali, che hanno tratto vantaggio dall'integrazione di router, pianificatori e subagent di dominio nel ciclo principale dell'agente. Nei nostri confronti tra diverse distribuzioni aziendali, un singolo agente con competenze ha spesso superato in termini di qualità sia il design con un unico prompt per tutto sia quello basato su subagent, spesso a costi e latenza inferiori per attività.

Ad esempio, un'azienda ha riscontrato che la presenza di una dozzina di subagent specializzati all'interno del proprio agente rivolto ai clienti rendeva difficile mantenere un'esperienza coerente con il brand, aggiungendo inoltre latenze che penalizzavano l'esperienza dell'utente.

Spesso ci imbattiamo anche in proposte di design di agenti che seguono una progressione ormai nota: un classificatore di intenti, una pipeline di ragionamento a più fasi predefinita, la suddivisione degli utenti in segmenti, rami di raccomandazione separati e, al vertice, un orchestratore multi-agente.

In questi casi, il riscontro è spesso che gran parte di tale struttura svolgeva attività di cui il modello non aveva più bisogno; un unico chiaro prompt di sistema, quattro o cinque strumenti leggeri per i dati e rigorosi guardrail di output sarebbero sufficienti a coprire la maggior parte del caso d'uso.

Progettazione dei subagent

A scanso di equivoci, i subagent mantengono comunque un loro ruolo, anche alla frontiera della ricerca. Utilizzali quando:

  • un singolo ciclo agente subisce un degrado misurabile delle prestazioni dovuto al sovraccarico del contesto, oppure
  • è necessario affrontare più attività in parallelo, con nuove finestre di contesto che possono essere scartate una volta completata ciascuna attività, oppure
  • un singolo agente fatica a selezionare gli strumenti appropriati o il prompt di sistema contiene istruzioni conflittuali.

Troppo spesso, tuttavia, vediamo aziende che assegnano a ogni team o tipo di problema un subagent dedicato, e l'architettura degli agenti finisce per ricalcare il loro organigramma (la legge di Conway in azione).

Questo post spiega quando valutare l'integrazione dei subagent nel ciclo dell'agente principale, con le best practice che abbiamo appreso creando agenti all'interno di grandi organizzazioni.

Criticità nella creazione di agenti per le grandi organizzazioni

Le aziende spesso desiderano creare un agente che unisca più prodotti e funzionalità in un'unica interfaccia cliente.

In genere, ogni funzionalità è gestita da un team distinto; pertanto, le aziende iniziano consentendo a ogni team di sviluppare il proprio agente, dopodiché un team dedicato alla piattaforma centrale sviluppa un orchestratore da sovrapporvi. Ciò può assumere diverse strutture, tra cui quella di orchestratore-subagent o quella di un singolo agente con agenti specifici esposti come strumenti MCP.

Questa sembra la soluzione più semplice, ma introduce una complessità immediata relativa a:

  • Gestione del contesto: è necessario decidere quale contesto scambiare tra gli agenti, spesso perdendo dettagli durante lo scambio.
  • Proliferazione dei subagent: ogni team distribuisce il proprio subagent, quindi le aziende si trovano ad avere centinaia di subagent che si sovrappongono, senza standard vincolanti e senza un responsabile specifico.
  • Il Frankenprompt: ogni team aggiunge una frase al prompt di sistema, con conseguente creazione di regole conflittuali e mancanza di una voce coerente.
  • Valutazioni non verificate ed eccessivamente localizzate: ognuno aggiunge le proprie valutazioni eccessivamente ottimizzate per la rispettiva sottoattività. Nessuno è responsabile dell'intero insieme né lo gestisce, e la leadership prende decisioni basate su punteggi diluiti ed eccessivamente localizzati.
  • Latenza: la complessità architetturale dei sistemi multi-agente aumenta la latenza. Un cliente che ha confrontato il proprio harness multi-agente con un ciclo a singolo agente ha riscontrato che quest'ultimo offriva un tempo di esecuzione circa due volte più rapido.

Utilizzo di un ciclo di esecuzione dell'agente con divulgazione progressiva

Il design orchestratore-subagent descritto sopra rappresenta un approccio ragionevole per coordinare gli specialisti sviluppati dai vari team, ma spesso un approccio più efficace può consistere nel divulgare progressivamente il contesto tramite le skill e divulgare progressivamente gli strumenti tramite la ricerca di strumenti. In altre parole, l'agente vede brevi descrizioni delle skill e degli strumenti, che vengono caricate completamente solo quando necessario.

Ci sono tre motivi per cui questo approccio può avere senso:

  • Il contesto condiviso produce risposte migliori: per gli agenti che restano in esecuzione più a lungo, vogliamo che il contesto di diverse attività risieda nella finestra di contesto principale. Un agente che ha visto il risultato di ogni passaggio precedente è in grado di collegarli tra loro, ottenendo output più ricchi e approfondimenti migliori rispetto a una serie di riepiloghi forniti dai subagent. Ciò significa anche meno finestre di contesto e meno passaggi di consegne con perdita di informazioni.
  • La divulgazione progressiva previene il sovraccarico del contesto: questa tecnica consente ai team di creare singoli agenti in grado di svolgere un'ampia varietà di compiti senza dover caricare immediatamente l'intero contesto in un unico lungo prompt di sistema. Questo elimina la ragione principale per cui in precedenza i team dividevano il lavoro tra i subagent. Abbiamo infatti ridotto di oltre l'80% il prompt di sistema di Claude Code per modelli più avanzati, il che includeva tagli relativi alla divulgazione progressiva di competenze e strumenti.
  • I modelli sono più capaci: a partire da Opus 4.5, i modelli sono diventati in grado di gestire molto di più in un singolo ciclo di quanto la maggior parte dei team si aspettasse. Non è possibile disattivare il pensiero su Opus 5.5 e Fable 5.1. Inoltre, i modelli più recenti descrivono sempre più spesso i progressi e verificano il lavoro man mano che avanzano, il che rende superflui alcuni elementi dell'harness. Ogni nuovo modello ti consente di trasferire una parte maggiore del processo decisionale dall'harness al modello stesso. Un ciclo più semplice è anche più facile da trasferire al modello successivo; nelle migrazioni in cui abbiamo assistito i clienti, spesso sono state proprio le rigide strutture multiagente a impedire al nuovo modello di svolgere gran parte del lavoro.

La progettazione di un ciclo a singolo agente richiede disciplina: un prompt di sistema gestito con attenzione, descrizioni delle competenze e degli strumenti che si attivano nel momento giusto e una gestione deliberata delle finestre di contesto, della memoria e della presa di appunti. Questo articolo approfondisce le considerazioni relative alla migrazione e al design nelle sezioni successive.

Un team centrale dovrebbe essere responsabile della qualità end-to-end e del prompt di sistema, controllando ogni nuovo strumento e valutazione prima della sua distribuzione. Mantenere un team centrale di dimensioni ridotte aiuta ad accelerare le iterazioni e riduce i costi di coordinamento all'interno di una grande organizzazione.

Se scegli il percorso multiagente, inizia con il pattern più semplice (generatore-verificatore, orchestratore-subagent o altro) che possa funzionare. Definisci i confini in modo efficace suddividendo il lavoro in base al contesto: assegna a ogni subagent un'attività che richieda poco dal resto del sistema e fai in modo che restituisca un risultato compatto; esempi ideali sono percorsi di ricerca indipendenti, componenti separati con interfacce pulite o la verifica black box. Quando gli agenti vengono suddivisi per tipo di problema, partecipano a un "telefono senza fili", passandosi le informazioni avanti e indietro, con ogni trasferimento che degrada la fedeltà.

subagent suddivisi per problema

Come integrare i subagent nel ciclo dell'agente principale

Molti team hanno già un orchestratore e un insieme di agenti specializzati in produzione. Di seguito è riportato il design a ciclo singolo verso cui suggeriamo di lavorare:

  • Un modello e una finestra di contesto che gestiscono un ciclo aperto di strumenti, con limiti (budget di turni e di costo, gate di scrittura) impostati nell'harness.
  • A ogni turno, il modello genera un batch di chiamate agli strumenti. L'harness li esegue in parallelo e restituisce i risultati grezzi allo stesso modello, che decide quale sia il passaggio successivo: un altro batch, una domanda all'utente o una risposta.
  • Il ciclo si interrompe quando il modello risponde o raggiunge un limite di budget. Un obiettivo o un controllo di verifica può essere eseguito, facoltativamente, dopo la risposta.
  • Il modello scrive il proprio piano nel contesto al primo turno e lo revisiona man mano che arrivano i risultati. Questo è il cambiamento principale rispetto alla configurazione dell'orchestratore e degli agenti specializzati: il modello che redige il piano è anche quello che lo attua, quindi può apportare modifiche al piano a metà turno.
  • Il contesto viene comunque caricato ed è gestito dall'agente stesso:
    • Un passaggio di codice che riscrive il piano a partire da un catalogo di regole non è più necessario, poiché il modello decide ogni passaggio.
    • Le procedure di ordinazione e di dominio vengono trasferite in skills.
    • I limiti rigidi, come convalida e controlli di approvazione, e qualsiasi altra cosa che emerga nel corso di una conversazione, ad esempio la ricerca nella memoria, vengono spostati negli strumenti.
    • Il codice può ancora essere utilizzato per eseguire operazioni poco onerose e quasi sempre pertinenti, ad esempio, una fase di risoluzione di un'entità, nonché per gestire gli aspetti più meccanici, come la costruzione del payload, l'analisi dei flussi, la ripresa di un chiarimento, all'interno degli strumenti richiamati dal ciclo.

Questo design a ciclo unico contribuisce inoltre a raggiungere lo stato finale verso cui molti team stanno lavorando, ossia un agente che comprende gli obiettivi di alto livello di un utente e agisce a favore di quest'ultimo, poiché mantiene tutto ciò che l'agente ha imparato in un unico contesto.

I seguenti suggerimenti illustrano come un team potrebbe passare in modo graduale da un sistema multiagente a un ciclo a singolo agente e come diversi team possano continuare a contribuire a quell'agente lungo il percorso.

Valutazioni del completamento delle attività

Il primo passo consiste nel creare un set di valutazione che possa aiutarti a determinare se sia opportuno integrare un subagent nel ciclo principale dell'agente. La struttura di valutazione che abbiamo visto funzionare è costituita da un unico set condiviso end-to-end di proprietà di un team centrale, con set di valutazioni più piccoli forniti insieme a ciascuna skill dal team che le gestisce. Anche una serie di 10 esempi di riferimento è sufficiente per iniziare.

Valutare il messaggio finale dell'agente in base a una griglia di valutazione è un buon punto di partenza per monitorare la qualità delle risposte. Sebbene tu abbia ancora un orchestratore, dovresti anche monitorare l'accuratezza del routing e la corretta selezione del subagent. Una volta integrato un subagent, verifica invece se l'agente ha caricato la skill corretta o ha richiamato lo strumento corretto. È utile lavorare nel tempo per arrivare a valutazioni basate sul completamento delle attività, poiché sono queste a contare di più quando si confrontano le architetture.

Questa operazione può rivelarsi complessa in ambienti in cui i sistemi interni sono difficili da riprodurre e il coinvolgimento degli utenti è difficile da simulare. Un approccio che si è rivelato efficace al nostro interno consiste nel registrare i timestamp di eventi importanti, in modo da poterli riprodurre in seguito ed effettuarne la valutazione in modo mirato.

Riduzione dei subagent nel tempo

Evolvere verso un ciclo a singolo agente significa integrare i subagent in strumenti e skills. È possibile farlo unendo i subagent di dominio, richiamandoli come strumenti o sostituendoli con skill e strumenti.

integrazione dei subagent

Combinazione di agenti di dominio

Crea una piccola valutazione end-to-end prima di effettuare la prima fusione. Quindi incorpora i subagent in base al contesto condiviso, partendo da quelli più utilizzati.

Specialisti di merge che si concatenano sugli output reciproci, che trattano gli stessi dati o che vengono spesso richiamati insieme. Ad esempio, se una quota significativa del traffico di produzione è costituita da un agente specializzato seguito da un secondo, si tratta di una coppia strettamente accoppiata, il che la rende idonea a essere unita in un unico agente di dominio.

Subagent richiamati come strumenti

Quando si verifica una delle tre condizioni descritte sopra e decidi di mantenere un subagent, può essere efficace fare in modo che l'agente principale richiami i subagent come strumenti, così da poter continuare a gestire la conversazione con l'utente.

Consiglieremmo un trasferimento completo, in cui il subagent assume la responsabilità della conversazione, solo quando ha bisogno di parlare direttamente con l'utente. Tutto il resto può essere gestito con una skill e gli strumenti nel ciclo principale.

This will allow you to define a shared response schema for subagents, verify the conclusion against real data with the main agent, and trim the input to any final synthesis step. This is a good first step, as you don’t need to rewrite the subagents. It also gives you a baseline on the task-completion eval before deciding to fold any subagents into the main agent.

Tuttavia, rimarranno alcune modalità di errore:

  • Ogni specialista ha il proprio prompt, contesto, team proprietario e set di valutazioni
  • Ogni chiamata restituisce comunque un riepilogo con perdita di informazioni
  • Ogni chiamata è un ciclo annidato di modelli che aumenta la latenza

Integrazione dei subagent nell'agente principale tramite skill e strumenti

Integra i subagent nell'agente principale uno alla volta, trasformando i prompt di ciascuno in skill e le chiamate API in strumenti MCP. Confronta le prestazioni nelle valutazioni con e senza il subagent. Quindi decidi quali mantenere.

Quando fai confronti, non limitarti a esaminare il punteggio finale, ma osserva anche quali attività hanno cambiato esito. Quando abbiamo testato questa soluzione su un agente di supporto di esempio, integrare un subagent in un altro ha ridotto la latenza, ma ha anche compromesso un processo che fino ad allora superava i test. L'agente principale stava utilizzando lo strumento di ricerca degli ordini e rispondeva in autonomia, senza chiedere allo specialista delle spedizioni la data di consegna.

Prima di ogni modifica, assicurati che la valutazione preveda un'attività per ogni catena di agenti eseguiti insieme in produzione e per ogni regola che l'agente non deve violare, ed esegui ogni attività più di una volta, poiché un problema come questo si è verificato solo in un'esecuzione su due.

In che modo diversi team possono contribuire a un singolo agente

Il ragionamento di dominio può essere recuperato da knowledge base, skill e strumenti MCP. I singoli team possono trasferire la propria responsabilità dagli agenti a skill e strumenti, mentre un piccolo team centrale mantiene la responsabilità del prompt di sistema e della qualità end-to-end. Ciò implica esaminare nuove skill, strumenti e valutazioni prima del loro lancio.

Strumenti MCP

Gli strumenti sono la soluzione giusta quando l'agente deve intraprendere un'azione, leggere dati in tempo reale da un sistema o restituire un risultato in un formato fisso. Puoi anche utilizzare gli strumenti per continuare a richiamare i subagent durante la migrazione. Consigliamo di utilizzare strumenti raggruppati per intento dell'utente, non uno strumento per API, perché una volta superate le 30-50 definizioni di strumenti nel prompt di sistema, la scelta degli strumenti tende a peggiorare.

Utilizza ricerca strumenti con caricamento differito, limita i prerequisiti rigorosi e trasferisci quelli necessari negli strumenti. Ad esempio, se Y richiede l'output di X, lo strumento di Y lo verifica e restituisce un'istruzione su cui il modello può agire. Le autorizzazioni per utente funzionano allo stesso modo. Ogni strumento verifica ciò che l'utente chiamante può vedere o fare e restituisce un semplice rifiuto leggibile dal modello. In questo modo, un unico ciclo può servire utenti con accessi diversi senza che sia necessario un agente separato per ogni livello di autorizzazione.

Skills

Le Skills sono la soluzione giusta quando un agente deve sapere come lavora un team, ad esempio i passaggi, le regole e le valutazioni discrezionali che un tempo erano contenuti nel prompt di un subagent specializzato.

Il nostro approccio all'espansione delle librerie di skill consiste nel restituire il lavoro di manutenzione alle persone che scrivono le skill. Claude può occuparsi del lavoro pesante grazie a skill in grado di creare, testare e ottimizzare altre skill.

Per evitare la proliferazione incontrollata delle skill, puoi assegnare a ogni team dei DRI responsabili delle proprie skill, che si assicurino che siano ben strutturate, distinte e rilasciate con valutazioni appropriate.

  • /skill-creator ti consente di creare nuove skill già ben formate e di verificare quelle esistenti per ridurle, eliminare i duplicati e ristrutturarle.
  • /skill-doctor ti consente di vedere quanto costa ogni skill della libreria e quanto spesso viene effettivamente utilizzata, nonché di eliminare quelle superflue.

Knowledge base

Le knowledge base sono la soluzione ideale per il materiale di riferimento di cui l'agente ha bisogno solo occasionalmente. Fatti e materiale di riferimento, come policy, definizioni delle metriche e specifiche di prodotto, possono essere resi disponibili tramite uno strumento di ricerca o consultazione richiamato dal modello oppure forniti come file di riferimento all'interno di una skill. Evita che sia il codice a recuperare questo contesto e a incollarlo nei prompt.

Strumenti per accelerare questo lavoro

Di recente abbiamo rilasciato una serie di skill per Claude API che possono aiutare nella maggior parte delle attività sopra menzionate. Il nostro kit di migrazione concatena queste skill in un unico flusso di lavoro guidato per valutare i sistemi multiagente e migrarli verso un ciclo a singolo agente. Include una demo che puoi provare prima di utilizzarlo sul sistema reale:

  • /claude-api build-eval: può aiutare a creare un primo set di valutazioni end-to-end di proprietà del team centrale o piccole valutazioni che ogni team rilascia insieme alla propria skill
  • /claude-api prompt-audit: può segnalare le istruzioni scritte per modelli meno recenti nei prompt, nelle skill e nelle descrizioni degli strumenti e proporre correzioni come diff. Puoi eseguirla sui prompt di sistema per individuare eventuali regole aggiunte per un modello precedente che ora rendono l'agente più lento o più rigido. Il DRI di ogni team può inoltre eseguirlo sulle proprie skill e descrizioni degli strumenti.
  • /claude-api hillclimb: può migliorare iterativamente un'app rispetto a una valutazione esistente. Può essere utilizzato sia per il prompt di sistema sia per il confronto "folded in vs kept": dopo aver integrato un subagent in una skill con strumenti, lascia che iteri sulle descrizioni della skill e degli strumenti e verifica se la versione integrata eguaglia o supera il subagent.
  • /claude-api cost-optimize: analizza la destinazione delle chiamate e propone risparmi grazie a opzioni come il caching dei prompt, la riduzione dei token di input e output non necessari, il livello di effort e la scelta del modello, una modifica alla volta. Questo può contribuire a ridurre costi e latenza per un determinato design.

Con l'evolversi dei modelli, evolvono anche la nostra comprensione di come utilizzarli al meglio, nonché le linee guida sulle best practice. Ciò rende qualsiasi architettura meno importante del principio alla base: misurare, modificare un elemento alla volta e mantenere ciò che regge.

Questo è uno di quei casi. Man mano che i modelli diventano più capaci e gli agenti operano più a lungo, un numero maggiore di subagent può trasformarsi in skill e strumenti. Tuttavia, non è necessario effettuare questo passaggio in un'unica fase. Crea una piccola valutazione end-to-end, integra un solo subagent e mantienilo come tale solo se la versione integrata ottiene un punteggio inferiore, quindi ripeti il processo.

Trasforma il modo in cui opera la tua organizzazione con Claude

Iscriviti alla newsletter per sviluppatori

Aggiornamenti sui prodotti, guide pratiche, storie dalla community e molto altro. Recapitati ogni mese nella tua casella di posta.

Inserisci il tuo indirizzo email se desideri ricevere la nostra newsletter mensile per sviluppatori. Puoi annullare l'iscrizione in qualsiasi momento.