Più agenti Claude Code in parallelo: che cosa funziona, che cosa si rompe
Per far lavorare più agenti Claude Code contemporaneamente, date a ciascuno il suo git worktree e il suo branch. Oltre i tre o quattro agenti, i veri problemi sono i conflitti sui file, la revisione e il costo: servono un ticket per agente, un perimetro di file e una revisione prima del merge.
Perché parallelizzare, e che cosa si rompe già dal secondo agente
Una squadra di sviluppo umana non lavora quasi mai con un solo ingegnere alla volta su un progetto attivo: più persone avanzano in parallelo su parti diverse dello stesso repository, con un sistema di branch, revisione e integrazione ormai rodato da anni per questo scopo. La stessa logica si applica agli agenti Claude Code: in linea di principio nulla impedisce di far avanzare più agenti sullo stesso progetto allo stesso tempo, purché ciascuno resti nel proprio perimetro, allo stesso modo in cui ci si aspetterebbe da un ingegnere umano che non tocchi il modulo di un collega senza un coordinamento preventivo.
Far lavorare un solo agente Claude Code alla volta ha un limite semplice: il tempo totale resta la somma del tempo di ogni attività, anche quando più attività non hanno assolutamente nulla in comune. Tradurre un articolo in sei lingue, correggere un bug lato server mentre si amplia una pagina di documentazione, o portare avanti tre ticket indipendenti della stessa scheda di lavoro sono casi in cui nulla obbliga ad aspettare che un agente finisca prima di lanciare il successivo. Parallelizzare più agenti Claude Code, che sia tramite sub-agenti nella stessa sessione, tramite agent team coordinati, o tramite sessioni indipendenti in worktree separati, promette di ridurre questo tempo totale al tempo dell'attività più lunga piuttosto che alla somma di tutte le attività.
Il lancio di più agenti in parallelo non è quasi mai il problema: qualsiasi terminale può aprire più sessioni Claude Code in pochi secondi. I problemi iniziano non appena due agenti toccano, anche brevemente, uno stato condiviso, che si tratti di un file, di un branch, di una porta del server locale o di un budget di revisione già occupato altrove. Tornano quattro sintomi, più o meno in quest'ordine di comparsa man mano che il numero di agenti aumenta.
Il primo sintomo è il conflitto sui file: due agenti che modificano lo stesso file nello stesso momento, nella stessa directory di lavoro, finiscono quasi sempre per sovrascrivere una parte del lavoro l'uno dell'altro, soprattutto quando nessuno dei due rilegge lo stato più recente prima di effettuare il commit. Il rischio cresce ancora di più quando i due agenti condividono la stessa directory di lavoro Git, il che significa che ciascuno vede, nello stesso istante, le modifiche non committate dell'altro, ben prima che uno dei due abbia potuto convalidarle.
Il secondo sintomo è il contesto perduto: un agente che riprende un'attività dopo che un altro agente ha modificato un file vicino lavora a volte su una versione del codice che non esiste già più, perché il proprio contesto di conversazione non è mai stato informato del cambiamento. Questo scarto non produce sempre un errore visibile subito; spesso produce un codice che compila, che sembra corretto a livello locale, ma che contraddice una decisione presa nel frattempo da un agente vicino sullo stesso file o su un file che ne dipende.
Il terzo sintomo è la revisione che va in saturazione: ogni agente in più produce un diff in più da rileggere, e la revisione non si parallelizza con la stessa facilità della scrittura, perché richiede un'attenzione umana o una revisione automatizzata la cui capacità resta, invece, più o meno fissa. Secondo uno studio di CodeRabbit ripreso da The Register a dicembre 2025, le pull request co-scritte con l'IA contengono 1,7 volte più problemi rispetto alle pull request scritte senza assistenza: moltiplicare gli agenti senza moltiplicare la capacità di revisione equivale ad accumulare un debito che si vede solo al momento dell'integrazione.
Il quarto sintomo è il costo, che sale più in fretta del numero di agenti piuttosto che allo stesso ritmo: ogni agente ricostruisce una parte del proprio contesto a ogni sessione, ogni conflitto risolto a posteriori consuma di nuovo token per rileggere e correggere, e un coordinamento mal definito tra agenti aggiunge andirivieni che non esisterebbero con un solo agente. La documentazione di Claude Code sulla gestione dei costi raccomanda, proprio per questo motivo, di definire il perimetro di ogni sessione prima di lanciarla piuttosto che lasciarlo crescere nel corso della conversazione.
Questi quattro sintomi non sono argomenti contro la parallelizzazione in sé: indicano semplicemente che oltre un agente, il lavoro di coordinamento non scompare, si sposta dalla scrittura del codice alla definizione del perimetro, dei criteri e della revisione. La sezione seguente descrive, passo per passo, come porre questo quadro prima di lanciare il secondo agente piuttosto che dopo aver constatato il primo conflitto.

Metodo passo per passo per mantenere il controllo
Cinque pratiche coprono la maggior parte dei sintomi descritti sopra. Nessuna dipende da uno strumento in particolare: si applicano sia ai sub-agenti nella stessa sessione sia alle sessioni indipendenti lanciate in worktree separati. Si susseguono in quest'ordine, perché ciascuna riduce un rischio che la successiva non può più recuperare del tutto una volta che si è prodotto.
La prima pratica è un worktree Git e un branch per agente. Il comando git worktree add crea una directory di lavoro separata, con il proprio stato dei file, pur condividendo la stessa cronologia Git del repository principale: due agenti installati in due worktree diversi non possono più, per costruzione, vedere né sovrascrivere i file non committati l'uno dell'altro, anche se lavorano nello stesso istante sullo stesso repository. La documentazione di Claude Code sui flussi di lavoro comuni descrive esattamente questo schema per far girare più sessioni in parallelo senza che si pestino i piedi a vicenda, con ogni sessione che resta sul proprio branch finché una fusione esplicita non avvicina il lavoro degli altri. Un agente che termina la propria attività lascia dietro di sé un branch pronto per la revisione, che l'integrazione può accettare o respingere senza mai aver toccato la directory di lavoro degli agenti ancora in corso.
La seconda pratica è un perimetro di file definito per attività, prima che l'agente inizi a scrivere. Un ticket che precisa esattamente quali file o quali cartelle un agente può modificare elimina gran parte del rischio di conflitto ancora prima che si verifichi, dato che due agenti i cui perimetri non si sovrappongono non possono, per definizione, scrivere sullo stesso file. Questo perimetro deve restare più stretto di quanto permetterebbe in generale la scheda di ruolo dell'agente, perché è il ticket in corso, non il ruolo dell'agente, a determinare ciò di cui un'attività precisa ha realmente bisogno. Un perimetro troppo ampio, anche con buone intenzioni, equivale a ridare agli agenti la stessa esposizione di un solo agente senza alcuna suddivisione, solo distribuita tra più sessioni invece che concentrata in una sola.
La terza pratica è scrivere i criteri di accettazione prima di lanciare l'agente, non dopo aver letto la sua consegna. Un criterio scritto in anticipo, del tipo « il comando di build passa » o « le cinque traduzioni riprendono le stesse sezioni », dà all'agente un obiettivo verificabile e dà al suo revisore un test oggettivo piuttosto che un'impressione generale sulla qualità del risultato. Senza un criterio preventivo, la revisione deriva verso una valutazione caso per caso, che diventa presto incoerente da un agente all'altro e da un'attività all'altra. Questo stesso criterio serve anche da punto di arresto: un agente che non riesce a soddisfarlo segnala un blocco prima della revisione, piuttosto che consegnare un risultato approssimativo sperando che passi inosservato.
La quarta pratica è una revisione prima di qualsiasi integrazione, mai dopo. Un diff riletto prima della fusione può ancora essere corretto senza influire sul lavoro degli altri agenti; un diff fuso prima e riletto dopo obbliga a disfare una cronologia già condivisa, con il rischio di eliminare, allo stesso tempo, un lavoro valido svolto nel frattempo da un agente vicino su un file che ne dipende. La revisione deve riguardare il diff reale, non solo il riassunto che l'agente fornisce del proprio lavoro, proprio perché un riassunto ottimistico non rivela sempre un criterio di accettazione rimasto insoddisfatto. Questa disciplina costa un po' di tempo a ogni consegna, ma costa sempre meno che districare, dopo una fusione, quale dei due agenti ha prodotto quale parte di uno stesso file.
La quinta pratica è limitare il numero di sessioni simultanee a ciò che la revisione può realmente assorbire. La documentazione di Claude Code sui sub-agenti e sugli agent team raccomanda di iniziare con tre-cinque compagni di squadra prima di considerare di andare oltre, ricordando che due agenti sullo stesso file producono quasi sempre una sovrascrittura piuttosto che una fusione pulita. Questo numero non è un limite tecnico del protocollo; è un limite pratico di ciò che un revisore, umano o automatizzato, può verificare seriamente prima di integrare. Aumentare questo numero resta possibile più avanti, una volta che il perimetro di file, i criteri di accettazione e la revisione prima della fusione sono già rodati su un numero ridotto di agenti.
Tabella delle trappole e delle contromisure
La tabella seguente riprende le trappole più frequenti osservate oltre i due agenti, con il loro sintomo concreto e la contromisura che lo evita; ogni contromisura rimanda direttamente a una delle cinque pratiche della sezione precedente.
| Trappola | Sintomo | Contromisura |
|---|---|---|
| Due agenti sullo stesso file | Sovrascrittura di una parte del lavoro prima del commit o alla fusione | Un worktree e un branch per agente |
| Perimetro di attività poco chiaro | Due agenti modificano file che si sovrappongono senza saperlo | Un perimetro di file scritto nel ticket prima del lancio |
| Criterio di accettazione assente | La consegna sembra completa ma non risponde alla vera richiesta | Criteri di accettazione scritti prima del lancio dell'agente |
| Fusione prima della revisione | Un difetto scoperto in seguito obbliga a disfare una cronologia condivisa | Una revisione del diff reale prima di qualsiasi integrazione |
| Troppe sessioni contemporaneamente | La revisione va in saturazione e il debito di codice si accumula senza essere visto | Un numero di sessioni simultanee limitato a ciò che la revisione assorbe |
| Contesto non condiviso tra agenti | Un agente lavora su una versione del codice già cambiata da un altro | Un ticket per agente con il proprio perimetro, riletto prima della fusione |
Come procede Atipol
In Atipol, ogni agente lavora nel proprio worktree Git, sul proprio branch: due agenti non modificano mai gli stessi file nello stesso istante, per costruzione piuttosto che per disciplina individuale. Ogni ticket riserva un perimetro di file prima che l'agente inizi a scrivere, e due ticket in corso non possono riservare lo stesso perimetro: il rischio di sovrascrittura tra due agenti viene eliminato prima del primo commit piuttosto che al momento della fusione. Questa riserva si verifica proprio nel momento in cui il ticket viene assegnato a un agente, non a posteriori durante una revisione di fine settimana, il che evita che una sovrapposizione venga scoperta solo dopo che entrambi gli agenti hanno già scritto sulle stesse righe.
Ogni ticket richiede criteri di accettazione scritti prima del lancio dell'agente, il che evita che un'attività termini senza sapere con precisione che cosa doveva essere vero per considerarla fatta. L'agent lead del progetto rilegge ogni consegna prima di integrarla, e questa integrazione riesegue i controlli del progetto piuttosto che fidarsi della sola revisione che l'ha preceduta. Questa revisione riguarda il diff reale prodotto dall'agente, e l'integrazione che segue non si accontenta del parere del revisore: riesegue essa stessa i controlli del progetto, affinché una svista nella revisione non diventi un difetto silenzioso nel branch principale.
Il numero di sessioni simultanee si regola a livello di progetto, affinché il carico di revisione e il costo in token restino sotto il controllo del team piuttosto che crescere con il solo numero di agenti che si potrebbero lanciare. Questa regolazione resta nelle mani del team che porta avanti il progetto, non un parametro fissato una volta per tutte dalla piattaforma stessa. Atipol non è limitato a Claude Code: lo stesso quadro di ticket, perimetro di file e revisione prima dell'integrazione si applica ad altri agenti di sviluppo.

Domande frequenti
Serve un worktree per ogni agente Claude Code?
Non appena due agenti toccano lo stesso repository nello stesso momento, sì: un worktree e un branch per agente eliminano il rischio di conflitto sui file alla radice piuttosto che gestirlo a posteriori.
Quanti agenti si possono lanciare in parallelo?
Tanti quante sono le attività realmente indipendenti. Il limite concreto non è il numero di sessioni che si possono aprire, ma la capacità di revisione e il budget disponibili per verificarle.
Che cosa fare se due agenti devono toccare lo stesso file?
Metterli in sequenza piuttosto che parallelizzarli su quel file specifico, oppure suddividere l'attività affinché ogni agente riceva un perimetro di file distinto prima di iniziare.
Un sub-agente sostituisce un worktree separato?
No: un sub-agente resta nella stessa sessione e nello stesso contesto, per un'attività secondaria breve. Un worktree separato serve per il lavoro lungo e indipendente, sul proprio branch.
Come evitare che la revisione diventi il collo di bottiglia?
Limitando il numero di sessioni simultanee a ciò che un revisore può verificare seriamente, e scrivendo i criteri di accettazione prima del lancio piuttosto che dopo la consegna.
Come impedisce Atipol che due agenti riservino lo stesso perimetro?
Ogni ticket riserva un perimetro di file prima che l'agente inizi a scrivere, e due ticket in corso non possono riservare lo stesso perimetro: il conflitto viene eliminato prima del primo commit.
Fonti
- Claude Code, Flussi di lavoro comuni (git worktree)
- Claude Code, Sub-agenti
- Git, git-worktree
- Claude Code, Gestione dei costi
- The Register, CodeRabbit, 17/12/2025
Per collegare questo metodo a un quadro completo di governance, consultate la nostra guida alla governance degli agenti IA.
Per quanto questi agenti in parallelo costano in pratica, consultate il nostro articolo sul costo degli agenti IA.
La demo pubblica mostra un'organizzazione fittizia in funzione, senza account. L'offerta gratuita include un progetto, tre agenti e un agent lead.
