Protocole Agent2Agent (A2A) de Google : Un guide avec des exemples

Les agents d'IA redéfinissent la manière dont les tâches sont automatisées, les décisions sont prises et les systèmes logiciels collaborent. Mais à mesure que les organisations construisent des agents plus autonomes, la nécessité d'une communication normalisée entre les fournisseurs et les cadres devient essentielle. C'est là que Agent2Agent (A2A) entre en jeu.

A2A est un protocole ouvert et neutre développé par Google pour normaliser la collaboration entre les agents d'intelligence artificielle de différents systèmes.

Dans ce tutoriel, je vais vous aider à comprendre comment A2A fonctionne, ses principes de conception, et comment il peut alimenter des flux de travail multi-agents dans le monde réel à travers les domaines, et en quoi il est différent de MCP.

Qu'est-ce que l'agent 2 agent (A2A) ?

Agent2Agent (A2A) est un protocole ouvert qui permet l'interopérabilité entre des agents opaques (boîte noire). Il permet aux agents de l'IA de :

• Se découvrir mutuellement
• Échanger des tâches structurées
• Réponses aux flux
• Traiter les conversations à plusieurs tours
• Opérer à travers des modalités telles que le texte, les images, la vidéo et les données.

Permettez-moi d'essayer d'expliquer l'idée principale de l'A2A en vous guidant à travers le diagramme ci-dessous :

Source : Google

Dans l'image, deux agents sont représentés : un agent Google (en bleu) et un autre agent (en vert), provenant probablement d'un service tiers. Les deux agents tentent de traiter deux types de documents ou de tâches. L'agent vert réussit les deux, comme l'indiquent les coches vertes, tandis que l'agent Google réussit l'un et échoue dans l'autre.

Cette divergence met en évidence la nécessité de la négociation et du partage d'informations, éléments centraux du protocole A2A.

Principes de conception d'Agent2Agent

L'A2A s'articule autour de cinq principes fondamentaux visant à accomplir des tâches pour les utilisateurs finaux sans partager de mémoire, de pensées ou d'outils. Ces cinq principes sont les suivants

• Adopter les capacités agentiques: Les agents collaborent sans partager de mémoire, d'outils ou de plans d'exécution.
• Construit sur des normes ouvertes: A2A utilise HTTP, JSON-RPC et SSE pour assurer une interopérabilité facile avec les piles technologiques existantes.
• Sécurisé par défaut: Il suit les schémas d'authentification OpenAPI et fournit une sécurité de niveau entreprise.
• Prise en charge des tâches de longue durée: A2A est conçu pour gérer les tâches d'arrière-plan, les approbations humaines en boucle et les mises à jour en continu.
• Modalité agnostique: Il gère les images, l'audio, les PDF, le HTML, le JSON et d'autres formats structurés/non structurés.

Ces principes de conception font d'A2A l'épine dorsale d'écosystèmes multi-agents évolutifs et prêts pour l'entreprise.

Comment fonctionne l'A2A ?

Dans cette section, nous allons nous plonger dans les rouages du protocole Agent2Agent et comprendre l'architecture et le cycle de vie de la communication entre agents. Nous explorerons les principaux acteurs impliqués, les couches de transport et d'authentification, et la découverte via les cartes d'agent.

Acteurs et protocoles

Le protocole A2A définit trois acteurs principaux :

• Utilisateur: L'utilisateur final initie une tâche.
• Agent client: Le demandeur qui formule et envoie une tâche au nom de l'utilisateur.
• Agent distant: L'agent destinataire qui exécute la tâche et renvoie les résultats.

Pour en revenir à notre exemple de diagramme ci-dessus, l'agent bleu est l'agent client et l'agent vert est l'agent distant.

Cartes d'agent et découverte

Les agents publient leurs métadonnées et leurs capacités au moyen d'un document JSON normalisé appelé "carte d'agent", généralement hébergé à l'adresse /.well-known/agent.json. Cette carte contient

• Nom, version et URL d'hébergement
• Description et fournisseur de services
• Modalités d'entrée/sortie et types de contenu pris en charge
• Méthodes d'authentification 
• Liste des compétences des agents avec étiquettes et exemples

La découverte peut se faire par le biais de DNS, de registres, de places de marché ou de catalogues privés.

Objets de communication essentiels

Au cœur de la communication A2A se trouve le site Task, c'est-à-dire un objet structuré qui représente une unité atomique de travail. Les tâches ont des états de cycle de vie tels que soumis, en cours d'exécution, à saisie obligatoire ou terminé.

Chaque site Task comprend

• Messages: Elles sont utilisées pour les échanges conversationnels entre le client et l'agent distant.
• Artéfacts: Il s'agit de résultats immuables créés par l'agent distant.
• Pièces détachées: Blocs de données autonomes contenus dans des messages ou des artefacts tels que du texte brut, des blobs de fichiers ou du JSON.

Exemple de flux de travail A2A

Comprenons le fonctionnement de l'A2A à travers un exemple de flux de travail :

1. L'utilisateur lance une tâche : L'utilisateur envoie une demande à un agent client, par exemple "Planifier le remplacement d'un ordinateur portable".
2. L'agent client découvre un agent distant : L'agent client recherche d'autres agents capables à l'aide d'une carte d'agent hébergée à un URL public ou privé. Ce fichier JSON comprend les compétences, les modalités prises en charge, l'authentification et l'URL du service.
3. L'agent client envoie un message à l'adresse Task: L'agent client envoie une demande task/send à l'agent distant sélectionné, en utilisant JSON-RPC 2.0 sur HTTP. La charge utile contient :
• A ID de la tâche
• Un identifiant de session (facultatif)
• Un message avec une ou plusieurs parties (par exemple, texte, fichier, JSON)
4. L'agent distant répond : L'agent distant traite la tâche et répond par :
• Résultats immédiats (via artefact)
• Messages intermédiaires (par message)
• Ou demande plus d'informations (en réglant l'état sur "input-required")
5. Streaming et mises à jour push (si asynchrone) : Si la tâche est de longue durée, l'agent distant peut renvoyer des résultats partiels à l'aide d'événements envoyés par le serveur (SSE). Si le client se déconnecte, les notifications push peuvent être envoyées à un webhook sécurisé fourni par le client.
6. Transitions de l'état de la tâche : La tâche passe par différents états : soumise → en cours → entrée requise → terminée. À tout moment, l'agent peut émettre des mises à jour ou de nouveaux artefacts pour le client.
7. Artéfacts et messages : Alors que les messages sont utilisés pour la communication ou la clarification (par exemple, "Veuillez télécharger vos reçus"), les artefacts sont utilisés pour présenter les résultats finaux tels que le rapport PDF, le résumé de l'analyse, la liste JSON, etc.
8. L'agent client reprend ou termine la tâche : Si des données sont nécessaires, l'agent client les recueille auprès de l'utilisateur et envoie un message de suivi à l'adresse task/send. Une fois la tâche terminée, le client peut récupérer tous les artefacts à l'aide de task/get.

Exemple A2A : Résolution des tickets du service d'assistance informatique

Imaginez un système d'assistance informatique d'entreprise qui utilise des agents d'IA pour gérer et résoudre de manière autonome les tickets d'assistance. Dans cette configuration, un agent utilisateur reçoit une requête du type :

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

L'agent utilisateur orchestre ensuite un processus de résolution en collaborant avec plusieurs agents distants via A2A.

Voici comment les agents interagissent via A2A dans le scénario ci-dessus :

• L'agent client envoie une tâche à l'agent de diagnostic du matériel, lui demandant de vérifier l'appareil.
• Si le matériel est en bon état, il passe à l'agent de reprise du logiciel, qui évalue les mises à jour récentes.
• Si le retour en arrière échoue, l'agent de remplacement des appareils est engagé pour procéder à un échange de matériel.

Chaque agent fonctionne de manière indépendante, expose une carte d'agent avec ses capacités et communique de manière asynchrone par le biais de tâches structurées. Les agents peuvent :

• Les journaux de flux ou les diagnostics en tant qu'artefacts
• Interrompre le flux si une intervention de l'utilisateur est nécessaire
• Envoyez des mises à jour push au fur et à mesure qu'ils accomplissent leur tâche

Il s'agit d'un cas d'utilisation purement A2A, car :

• Aucun outil structuré tel que des API ou des moteurs OCR n'est impliqué.
• Toute la coordination se fait entre des agents opaques qui collaborent entre eux.
• Les agents agissent comme des pairs avec une logique de décision individuelle et une gestion native des modalités.

A2A vs MCP : Quand utiliser quoi ?

A2A et MCP relèvent des défis différents mais complémentaires dans les systèmes agentiques. Alors que l'A2A vise à permettre aux agents de collaborer en tant qu'homologues autonomes, le protocole de contexte de modèle (MCP) est orienté vers la connexion des agents avec des outils structurés et des ressources externes.

Pourquoi avons-nous besoin à la fois d'A2A et de MCP ?

Les protocoles créent des normes d'interopérabilité. Dans le monde agentique, deux types d'interopérabilité sont essentiels :

• Interopérabilité des outils (MCP): Agents appelant des fonctions structurées, des API ou des outils.
• Interopérabilité des agents (A2A): Agents collaborant en langage naturel ou en modalités mixtes.

Exemple : Processus d'approbation des prêts

Imaginez un système multi-agents qui automatise les approbations de prêts pour une institution financière.

Voici comment A2A et MCP fonctionnent ensemble dans ce scénario :

Étape 1 : Prétraitement de l'application à l'aide d'outils et d'API (MCP)

Un agent LoanProcessor reçoit une demande de prêt de la part de l'utilisateur. Il utilise MCP pour :

• Appeler l'API d'une cote de crédit
• Il récupère ensuite l'historique des transactions bancaires à partir d'une source de données sécurisée.
• Enfin, il valide les documents téléchargés à l'aide d'un logiciel de reconnaissance optique de caractères (OCR).

Étape 2 : Coordination multi-agents pour la prise de décision finale (A2A)

Sur la base des données structurées de l'étape 1, l'agent utilise l'A2A pour :

• Collaborer avec RiskAssessmentAgent pour évaluer le risque de l'emprunteur
• Elle consulte ensuite un site ComplianceAgent pour s'assurer que le prêt répond aux exigences légales et réglementaires.
• En cas d'approbation, il passe le relais à DisbursementAgent pour programmer le transfert de fonds.

Conclusion

Agent2Agent (A2A) est le chaînon manquant dans les systèmes multi-agents à grande échelle. Avec des frontières claires entre les agents, une communication structurée basée sur les tâches et une prise en charge intégrée du streaming et du push, il permet de créer des écosystèmes d'agents modulaires, découvrables et évolutifs.

A2A est conçu pour répondre aux besoins réels des entreprises et est sécurisé, asynchrone, flexible en termes de modalités et indépendant des fournisseurs. Que vous utilisiez ADK de Google, LangGraph, CrewAI ou votre propre framework, A2A aide vos agents à parler aux agents.

Pour en savoir plus sur les agents d'intelligence artificielle, je vous recommande ces blogs :

• CrewAI : Un guide avec des exemples de systèmes d'agents multi IA
• L'IA agentique : Fonctionnement, avantages, comparaison avec l'IA traditionnelle