Il protocollo Agent2Agent (A2A) di Google: guida con esempi

Gli agenti AI stanno cambiando il modo in cui si automatizzano le attività, si prendono decisioni e collaborano i sistemi software. Ma man mano che le organizzazioni costruiscono agenti sempre più autonomi, diventa essenziale standardizzare la comunicazione tra vendor e framework diversi. È qui che entra in gioco Agent2Agent (A2A).

A2A è un protocollo open, neutrale rispetto ai vendor, sviluppato da Google per standardizzare la collaborazione tra agenti AI su sistemi diversi.

In questo tutorial, ti guiderò per capire come funziona A2A, i suoi principi di progettazione e come può alimentare workflow multi-agente reali in vari domini, e in che cosa differisce da MCP.

Che cos’è Agent 2 Agent (A2A)?

Agent2Agent (A2A) è un protocollo open che abilita l’interoperabilità tra agenti opachi (black-box). Consente agli agenti AI di:

• Scoprirsi a vicenda
• Scambiarsi task strutturati
• Eseguire streaming delle risposte
• Gestire conversazioni multi-turno
• Operare su modalità diverse come testo, immagini, video e dati.

Provo a spiegare l’idea principale di A2A guidandoti nell’analisi del diagramma qui sotto:

Nell’immagine sono rappresentati due agenti: un agente Google (in blu) e un altro agente (in verde), probabilmente di un servizio di terze parti. Entrambi gli agenti provano a elaborare due tipi di documenti o task. L’agente verde riesce in entrambi i casi, come indicano le spunte verdi, mentre l’agente Google riesce in uno e fallisce nell’altro.

Questa discrepanza evidenzia la necessità di negoziazione e condivisione di informazioni, componenti centrali del protocollo A2A.

Principi di progettazione di Agent2Agent

A2A è progettato attorno a cinque principi fondamentali per portare a termine task per conto degli utenti finali senza condividere memoria, pensieri o strumenti. Questi cinque principi includono:

• Abbracciare le capacità agentiche: gli agenti collaborano senza condividere memoria, strumenti o piani di esecuzione.
• Basato su standard aperti: A2A usa HTTP, JSON-RPC e SSE per garantire un’interoperabilità semplice con gli stack esistenti.
• Sicuro per impostazione predefinita: segue gli schemi di autenticazione OpenAPI e offre sicurezza di livello enterprise.
• Supporta task di lunga durata: A2A è progettato per gestire task in background, approvazioni con umano nel loop e aggiornamenti in streaming.
• Agnostico rispetto alla modalità: gestisce immagini, audio, PDF, HTML, JSON e altri formati strutturati/non strutturati.

Questi principi rendono A2A la spina dorsale di ecosistemi multi-agente scalabili e pronti per l’enterprise.

Come funziona A2A?

In questa sezione approfondiremo il funzionamento interno del protocollo Agent2Agent e capiremo l’architettura e il ciclo di vita della comunicazione tra agenti. Esploreremo gli attori principali, i livelli di trasporto e autenticazione e la discovery tramite Agent Card.

Attori e protocolli

Il protocollo A2A definisce tre attori principali:

• Utente: l’utente finale che avvia un task.
• Agente client: il richiedente che formula e invia un task per conto dell’utente.
• Agente remoto: l’agente destinatario che esegue il task e invia indietro i risultati.

Tornando all’esempio del diagramma sopra, l’agente blu è l’agente client e l’agente verde è l’agente remoto.

Agent card e discovery

Gli agenti pubblicano i propri metadati e le proprie capacità tramite un documento JSON standardizzato chiamato Agent Card, solitamente ospitato su /.well-known/agent.json. Questa card contiene:

• Nome, versione e URL di hosting
• Descrizione e provider del servizio
• Modalità di input/output e tipi di contenuto supportati
• Metodi di autenticazione 
• Elenco delle skill dell’agente con tag ed esempi

La discovery può essere gestita tramite DNS, registry, marketplace o cataloghi privati.

Oggetti di comunicazione core

Al centro della comunicazione A2A c’è il Task, ossia un oggetto strutturato che rappresenta un’unità di lavoro atomica. I task hanno stati di ciclo di vita come inviato, in lavorazione, input richiesto o completato.

Ogni Task include:

• Messaggi: usati per scambi conversazionali tra l’agente Client e l’agente Remoto
• Artifact: risultati immutabili creati dall’agente remoto.
• Parti: blocchi di dati autonomi all’interno di messaggi o artifact, come testo semplice, blob di file o JSON.

Esempio di workflow A2A

Vediamo come funziona A2A con un esempio di workflow:

1. L’utente avvia un task: l’utente invia una richiesta a un agente Client, ad es. «Programma la sostituzione di un laptop.»
2. L’agente Client scopre un agente Remoto: l’agente client cerca altri agenti capaci usando una Agent Card ospitata su un URL pubblico o privato. Questo file JSON include skill, modalità supportate, autenticazione e URL del servizio.
3. L’agente Client invia un Task: l’agente client invia una richiesta task/send all’agente Remoto selezionato, usando JSON-RPC 2.0 su HTTP. Il payload contiene:
• Un ID del task
• Un ID di sessione (opzionale)
• Un messaggio con una o più parti (es. testo, file, JSON)
4. L’agente Remoto risponde: l’agente remoto elabora il task e risponde con:
• Risultati immediati (tramite artifact)
• Messaggi intermedi (tramite message)
• Oppure richiede più informazioni (impostando lo stato su input richiesto)
5. Streaming e aggiornamenti push (se async): se il task è di lunga durata, l’agente remoto può trasmettere risultati parziali indietro usando Server-Sent Events (SSE). Se il client si disconnette, si possono inviare notifiche push a un webhook sicuro fornito dal client.
6. Transizioni di stato del task: il task passa attraverso gli stati: inviato → in lavorazione → input richiesto → completato. In qualsiasi momento, l’agente può emettere aggiornamenti o nuovi artifact per il client.
7. Artifact e messaggi: mentre i Messaggi sono usati per comunicazione o chiarimenti (es. «Carica le tue ricevute.»), gli Artifact servono per mostrare output finali come PDF di report, sintesi dell’analisi, elenco JSON, ecc.
8. L’agente Client riprende o completa il task: se servono input, l’agente client li raccoglie dall’utente e invia un task/send di follow-up. Una volta completato il task, il client può recuperare tutti gli artifact usando task/get.

Esempio A2A: risoluzione ticket help desk IT

Immagina un sistema di help desk IT aziendale che usa agenti AI per gestire e risolvere autonomamente i ticket di supporto. In questo setup, un agente utente riceve una richiesta come:

“My laptop isn’t turning on after the last software update.”

L’agente utente quindi orchestra un workflow di risoluzione collaborando con più agenti remoti tramite A2A.

Ecco come gli agenti interagiscono via A2A nello scenario sopra:

• L’agente Client invia un task all’agente di Diagnostica Hardware, chiedendo un controllo del dispositivo.
• Se l’hardware è a posto, il flusso passa all’agente di Rollback Software, che valuta gli aggiornamenti recenti.
• Se il rollback fallisce, entra in gioco l’agente di Sostituzione Dispositivo per avviare un cambio hardware.

Ogni agente opera in modo indipendente, espone una Agent Card con le proprie capacità e comunica in modo asincrono tramite Task strutturati. Gli agenti possono:

• Trasmettere log o diagnostiche come artifact
• Mettere in pausa il flusso se servono input dall’utente
• Inviare aggiornamenti push quando concludono la propria parte

Questo è un caso d’uso puramente A2A, perché:

• Non sono coinvolti strumenti strutturati come API o motori OCR
• Tutta la coordinazione avviene tra agenti opachi che collaborano
• Gli agenti agiscono come pari con logiche decisionali proprie e gestione nativa delle modalità

A2A vs MCP: quando usare cosa?

A2A e MCP risolvono sfide diverse ma complementari nei sistemi agentici. Mentre A2A si concentra sull’abilitare gli agenti a collaborare come pari autonomi, il Model Context Protocol (MCP) è pensato per collegare gli agenti a strumenti strutturati e risorse esterne.

Perché servono sia A2A che MCP?

I protocolli creano standard per l’interoperabilità. Nel mondo agentico, sono cruciali due tipi di interoperabilità:

• Interoperabilità degli strumenti (MCP): gli agenti chiamano funzioni, API o tool strutturati.
• Interoperabilità tra agenti (A2A): gli agenti collaborano in linguaggio naturale o modalità miste.

Esempio: workflow di approvazione prestito

Immagina un sistema multi-agente che automatizza l’approvazione dei prestiti per un istituto finanziario.

Ecco come A2A e MCP lavorano insieme in questo scenario:

Passo 1: Pre-elaborazione della domanda tramite tool e API (MCP)

Un agente LoanProcessor riceve dall’utente una domanda di prestito. Usa MCP per:

• Chiamare un’API di credit score
• Quindi recuperare la cronologia delle transazioni bancarie da una fonte dati sicura
• Infine, validare i documenti caricati usando un OCR

Passo 2: Coordinamento multi-agente per la decisione finale (A2A)

Sulla base dei dati strutturati del passo 1, l’agente usa A2A per:

• Collaborare con un RiskAssessmentAgent per valutare il rischio del richiedente

• Consultare poi un ComplianceAgent per assicurarsi che il prestito rispetti i requisiti legali e normativi

• Se approvato, passare la mano a un DisbursementAgent per programmare il trasferimento dei fondi.

Conclusione

Agent2Agent (A2A) è l’anello mancante nei sistemi multi-agente su larga scala. Con confini chiari tra agenti, comunicazione strutturata basata su task e supporto integrato per streaming e push, abilita ecosistemi di agenti modulari, rilevabili e scalabili.

A2A è progettato per le esigenze reali delle aziende ed è sicuro, asincrono, flessibile rispetto alle modalità e agnostico rispetto ai vendor. Che tu stia usando Google ADK, LangGraph, CrewAI o il tuo framework, A2A aiuta i tuoi agenti a parlare con altri agenti.

Per saperne di più sugli agenti AI, ti consiglio questi blog:

• CrewAI: una guida con esempi di sistemi multi-agente AI
• Agentic AI: come funziona, vantaggi, confronto con l’AI tradizionale