Come orchestrare più agenti IA con governance
I team che già applicano un perimetro di file e una revisione prima della fusione vedono comunque conflitti, perché il fallimento inizia prima: un brief non suddiviso, non gli agenti in parallelo stessi. La catena che previene davvero i conflitti va dal brief ai ticket, dai ticket agli agenti con perimetro riservato, poi alla revisione e all'integrazione che riesegue i controlli del progetto, qualunque sia il client MCP usato.
Il fallimento inizia prima che il primo agente venga eseguito
Un CTO che dice che far girare agenti in parallelo crea conflitti, duplicati e consegne non revisionate ha di solito già risolto metà del problema: un worktree e un branch dedicati per agente, un perimetro di file riservato per ticket, e una revisione prima della fusione, le cinque pratiche che una guida correlata di questo blog già copre, illustrate lì con Claude Code ma non limitate ad esso. Ciò che rompe la catena prima che tutto questo si applichi avviene più a monte: un brief che non è mai diventato un insieme di ticket distinti e delimitati fin dall'inizio, e una fase di revisione e integrazione che deve reggere indipendentemente da quale client abbia eseguito quale agente.
Niente di quanto segue ripete le pratiche di worktree, perimetro o revisione prima della fusione già documentate; copre invece le due parti della catena che si collocano ai due lati, trasformare un brief in ticket prima che inizi il lavoro in parallelo, e coordinare la revisione e l'integrazione una volta che diverse consegne arrivano nello stesso momento, costruito attorno all'architettura neutra rispetto all'host propria del Model Context Protocol piuttosto che attorno a un client specifico.
Trattare le cinque pratiche e questa catena come la stessa cosa è l'errore che porta un team ad adottare il perimetro di file e la revisione, a vedere comunque conflitti, e a concludere che le pratiche non funzionano; le pratiche risolvono ciò che accade una volta che i ticket esistono, e un team che passa direttamente ad agenti in parallelo da un brief non suddiviso resta esposto alla modalità di fallimento che quelle cinque pratiche non sono mai state pensate per intercettare.
L'architettura di MCP è neutra rispetto all'host, il che spiega perché la catena funziona con qualsiasi client
La panoramica dell'architettura propria del protocollo, versione 2026-07-28, descrive MCP come un modello client-server in cui un host MCP, « un'applicazione IA come Claude Code o Claude Desktop », crea un client MCP per ogni server a cui si connette, con ogni client che mantiene una connessione dedicata al proprio server. La documentazione fornisce un secondo host, diverso, come proprio esempio: quando Visual Studio Code si connette al server MCP di Sentry e poi a un server del file system locale, il runtime di Visual Studio Code istanzia un oggetto client separato per ciascuno.
Questo design spiega perché una catena di governance costruita su ticket, perimetro e revisione non debba essere riscritta per ogni client: l'host cambia, Claude Code, Claude Desktop, VS Code, o qualsiasi altra applicazione che implementi il protocollo, ma il modello di connessione client-server, e gli strumenti, le risorse e i prompt che un server espone, restano gli stessi sotto. Un ticket che nomina un perimetro di file e un criterio di accettazione vincola l'agente indipendentemente da quale host lo stia eseguendo quel giorno.
La stessa panoramica specifica due meccanismi di trasporto sotto questo modello client-server, un trasporto stdio per un server locale che parla con un solo client sulla stessa macchina, e un trasporto Streamable HTTP per un server remoto che serve molti client contemporaneamente, ciascuno con lo stesso formato di messaggio JSON-RPC indipendentemente dal trasporto o dall'host dall'altra parte.
Dal brief ai ticket: cosa deve essere deciso prima che inizi il lavoro in parallelo
Un brief, scritto per una persona, di solito raggruppa diverse modifiche che toccano parti diverse di una codebase o di un set di dati sotto un'unica descrizione. Suddividerlo in ticket che un insieme di agenti può eseguire in parallelo significa decidere, prima che qualsiasi agente parta, quali parti di quel brief possano essere lavorate senza toccare gli stessi file, quali dipendano dal completamento di un altro ticket prima, e quale dovrebbe invece restare un ticket unico che assorbe una modifica troppo intrecciata per essere suddivisa in sicurezza.
Ogni ticket risultante ha comunque bisogno delle due cose che un modello di governance basato su ticket già richiede: un perimetro di file riservato prima del lancio dell'agente, così che due ticket in corso non possano rivendicare gli stessi file, e criteri di accettazione scritti in anticipo, così che l'agente abbia un obiettivo verificabile e il revisore disponga di un test oggettivo piuttosto che del riassunto dell'agente stesso su ciò che ha fatto. Sbagliare questa suddivisione, perimetri che si sovrappongono, o criteri di accettazione copiati parola per parola dal brief originale senza essere resi specifici per ciascun ticket, è ciò che produce il lavoro duplicato e i conflitti di fusione che un CTO osserva a valle, anche quando tutte le altre pratiche della catena sono seguite correttamente.
Un brief che raggruppa una migrazione di database con una modifica dell'interfaccia non correlata è il caso più chiaro da suddividere prima di assegnare agenti, poiché i due toccano file disgiunti e comportano rischi indipendenti; un brief che modifica la firma di una funzione e ogni file che la richiama è il caso più chiaro da mantenere come ticket unico, poiché suddividerlo significherebbe assegnare a due agenti un perimetro sovrapposto sulla stessa modifica.
La catena, fase per fase
La tabella sottostante indica il controllo a ciascuna fase della catena, dal brief all'integrazione, e dove quel controllo appare già più in dettaglio altrove su questo blog piuttosto che ripeterlo qui.
| Fase | Cosa deve accadere | Dove è trattato |
|---|---|---|
| Dal brief ai ticket | Suddivisione in perimetri di file non sovrapposti, ciascuno con i propri criteri di accettazione | Questo articolo |
| Dal ticket all'agente in parallelo | Worktree e branch per agente, perimetro applicato prima del lancio | Guida sugli agenti Claude Code in parallelo |
| Dall'agente alla consegna | L'elenco degli strumenti e le azioni disponibili possono cambiare a metà esecuzione; gli agenti si risincronizzano tramite le notifiche MCP | Panoramica dell'architettura MCP |
| Dalla consegna alla revisione | Rivisto da qualcuno diverso dal richiedente, sul diff reale | Guida alla governance degli agenti IA |
| Dalla revisione all'integrazione | I controlli propri del progetto rieseguiti alla fusione, non presunti dalla sola revisione | Guida alla governance degli agenti IA |
Far girare agenti in parallelo senza perdere il filo
Una volta che diversi agenti sono in esecuzione sui propri perimetri riservati, il problema di coordinamento si sposta dai conflitti di file al rimanere sincronizzati su ciò che ogni agente può effettivamente fare. Il sistema di notifica proprio di MCP esiste esattamente per questo: un server può dire ai client connessi quando i suoi strumenti disponibili cambiano, per esempio quando uno strumento viene aggiunto, modificato o temporaneamente disabilitato, e un client che si è iscritto a quella notifica aggiorna il proprio elenco di strumenti invece di continuare a lavorare da uno obsoleto.
Per un team che fa girare diversi agenti contro gli stessi server MCP, questo significa che un cambio di perimetro o di permesso effettuato a metà esecuzione, uno strumento appena bloccato da un amministratore, un server messo offline per manutenzione, si propaga a ogni agente connesso tramite il protocollo stesso, invece di dipendere dal riavvio di ogni agente per recepire il cambiamento.
Questo è un meccanismo opt-in, non qualcosa che un client ottiene automaticamente: la documentazione propria del protocollo nota che le notifiche di cambiamento sono inviate solo ai client che vi si sono iscritti, e che il polling mantiene comunque un ruolo poiché la consegna è best-effort piuttosto che garantita, in particolare durante una riconnessione.
La revisione deve avvenire una volta sola, da parte di qualcuno che non ha fatto il lavoro
Far girare cinque ticket in parallelo non significa inventare cinque standard di revisione diversi; significa applicare la stessa regola, la persona che ha richiesto il lavoro non è quella che lo approva, a ogni consegna che arriva, che arrivino una alla volta o tutte nello stesso pomeriggio. La documentazione propria di GitHub sul suo agente di coding Copilot afferma lo stesso vincolo per un flusso di lavoro comparabile: un'approvazione da parte della persona che ha assegnato il lavoro non conta tra le revisioni richieste di un repository.
Ciò che cambia sotto carico parallelo non è lo standard, è il volume che un revisore deve assorbire in una volta, il che è il motivo per cui la stessa guida di pratiche già limita le sessioni simultanee a ciò che la revisione può effettivamente reggere, piuttosto che trattare la capacità di revisione come illimitata solo perché gli agenti stessi possono girare in parallelo.
Un limite sulle sessioni simultanee, già raccomandato altrove su questo blog a tre-cinque, è la forma pratica che questo assume: non è un limite su quanti agenti uno strumento può far girare, è un limite commisurato a quante consegne un revisore, o una rotazione di revisione, può effettivamente leggere nel diff prima di approvare.
L'integrazione riesegue i controlli, non si fida della sola revisione
Un diff che ha superato la revisione si fonde comunque in una cronologia condivisa da cui dipende ogni altro ticket in corso, il che spiega perché il modello di governance che questo blog ha già documentato riesegue i controlli propri del progetto al momento dell'integrazione, piuttosto che affidarsi solo alla revisione che l'ha preceduta. Sotto lavoro in parallelo questa fase conta di più, non di meno: due ticket revisionati e approvati possono comunque entrare in conflitto tra loro in modi che nessuno dei due revisori ha visto isolatamente, e l'integrazione è il momento in cui quel conflitto emerge davvero.
Trattare l'integrazione come un secondo controllo indipendente piuttosto che come una formalità dopo la revisione è ciò che impedisce a un conflitto di fusione di diventare un incidente di produzione scoperto a posteriori invece di una fusione bloccata intercettata prima.
Niente di tutto ciò richiede uno strumento diverso per il lavoro in parallelo rispetto al lavoro sequenziale; la stessa fase di riesecuzione all'integrazione si applica a un singolo ticket fuso da solo, semplicemente ha più occasioni di individuare qualcosa quando diversi ticket arrivano vicini nel tempo.
Costruire la catena all'interno di un team
Le pratiche di worktree, branch e perimetro di file che fanno funzionare la fase degli agenti in parallelo di questa catena, limite incluso, sono trattate per intero su atipol.ai/agentic-ai-blog/parallel-claude-code-agents. Come il costo di far girare diversi agenti in parallelo venga tracciato per ticket piuttosto che per mese è trattato su atipol.ai/agentic-ai-blog/ai-agent-costs, e il tour guidato che mostra un ticket passare dal brief al lavoro in parallelo alla revisione e all'integrazione dall'inizio alla fine si trova su atipol.ai/tour.
Domande frequenti
Una catena di orchestrazione multi-agente governata funziona con client IA diversi da Claude Code?
Sì. L'architettura propria del Model Context Protocol è neutra rispetto all'host: la sua documentazione descrive Claude Code, Claude Desktop e Visual Studio Code come esempi di host che creano ciascuno il proprio client MCP per server, con lo stesso modello di connessione client-server sotto. Una catena costruita su ticket, perimetro di file e revisione vincola l'agente indipendentemente da quale host lo stia eseguendo.
Cosa deve essere deciso prima di suddividere un brief in ticket per agenti in parallelo?
Quali parti del brief toccano file diversi e possono essere eseguite senza sovrapposizione, quali dipendono dal completamento di un altro ticket prima, e quali sono troppo intrecciate per essere suddivise in sicurezza e dovrebbero restare un ticket unico. Ogni ticket risultante ha comunque bisogno del proprio perimetro di file riservato e di criteri di accettazione scritti prima del lancio dell'agente.
Perché rieseguire i controlli all'integrazione se una consegna è già stata revisionata?
Perché una revisione copre un diff isolatamente, mentre l'integrazione è il momento in cui quel diff incontra ogni altra modifica fusa da quando è iniziata la revisione. Due ticket revisionati e approvati separatamente possono comunque entrare in conflitto tra loro in modi che nessuno dei due revisori ha visto, il che spiega perché rieseguire i controlli propri del progetto al momento della fusione individua ciò che la sola revisione non può.
Fonti
- Model Context Protocol, panoramica dell'architettura (versione del protocollo 2026-07-28), consultata il 11/11/2026
- GitHub Docs, Revisionare una pull request creata da Copilot, consultata il 11/11/2026
- NIST, AI Risk Management Framework (AI RMF 1.0), pubblicato il 26/01/2023
La demo pubblica mostra un'organizzazione fittizia in funzione, senza account. L'offerta gratuita include un progetto, tre agenti e un agent lead.
