Comprendre le protocole Agent2Agent (A2A)

Les agents IA sont de plus en plus utilisés pour automatiser des tâches complexes et répétitives. Jusqu’ici, chaque agent opérait souvent de façon isolée, ce qui limitait la portée des applications multi-agents. C’est pour répondre à ce défi qu’est né Agent2Agent (A2A), un nouveau protocole ouvert introduit par Google en avril 2025.

Comme son nom l’indique, A2A (pour « Agent2Agent ») fournit un langage commun pour que des agents, même créés par des entreprises ou en utilisant des frameworks différents, puissent communiquer et coopérer de manière standardisée.

Le protocole a été lancé avec le soutien de plus de 50 partenaires technologiques majeurs (Atlassian, Salesforce, SAP, ServiceNow, Deloitte, etc.), est le reflet d’une volonté collective d’établir un standard universel d’interopérabilité entre agents IA.

A quoi sert le protocole Agent2Agent ?

En environnement professionnel, les agents IA peuvent accomplir un éventail de tâches (assistance IT, aide aux services clients, planification logistique, etc.). Cependant, pour maximiser les bénéfices de l’IA agentique, il est crucial que ces agents puissent travailler ensemble au lieu d’agir en vase clos.

Un agent seul peut être limité, en combinant plusieurs agents spécialisés, on peut résoudre des problèmes plus complexes ou gérer des workflows de bout en bout.

Le protocole A2A répond à ce besoin en offrant un cadre commun pour l’échange d’informations et la coordination d’actions entre agents, quelle que soit leur technologie sous-jacente ou leur fournisseur.

Google a conçu Agent2Agent sur la base de son expérience des systèmes multi-agents à grande échelle, afin d’augmenter l’autonomie et la productivité des agents tout en réduisant les coûts à long terme pour les entreprises.

Du point de vue des développeurs, le principal avantage est de ne pas avoir à réinventer la roue pour faire dialoguer des agents : A2A offre une norme ouverte et neutre pour la collaboration multi-agents.

A2A permet aussi aux agents de coopérer sans exposer leur état interne ou leurs outils propriétaires, préservant ainsi la confidentialité des données et la propriété intellectuelle de chaque agent.

Principes et caractéristiques du protocole A2A

Google et ses partenaires ont défini cinq principes clés guidant la conception d’A2A :

• Exploitation des capacités agentiques : permettre aux agents de collaborer sans partager leur mémoire, leurs outils ou leurs plans internes. Chaque agent reste opaque (« boîte noire ») vis-à-vis des autres, ce qui renforce la sécurité tout en autorisant de véritables scénarios multi-agents (les agents ne sont pas cantonnés au rôle de simples “outils”)
• Basé sur des standards ouverts : s’appuie sur des technologies web éprouvées (HTTP, JSON-RPC 2.0, SSE) pour faciliter l’intégration dans les systèmes existants. Un agent A2A est essentiellement un service web exposant une API standard, ce qui rend le protocole interopérable avec les stacks IT courantes.
• Sécurisé par défaut : intègre nativement des mécanismes d’authentification et d’autorisation de niveau entreprise, alignés sur les schémas OAuth2/OpenID d’OpenAPI. Chaque échange entre agents peut ainsi être authentifié et chiffré, garantissant un haut niveau de sécurité adapté aux besoins des entreprises et respectant les standards fixés par les stack de LLMOps moderne
• Supporte les tâches de longue durée : conçu pour gérer aussi bien des requêtes instantanées que des processus s’étalant sur plusieurs heures ou jours. Agent2Agent prévoit un suivi d’état des tâches, des mises à jour en temps réel et même des notifications push asynchrones utile notamment quand un humain doit intervenir en cours de traitement.
• Agnostique en termes de modalités : ne se limite pas au texte. Le protocole permet d’échanger des contenus variés (texte, images générées, audio, vidéo, formulaires web, JSON structuré, etc.), et de négocier le format de réponse le plus approprié en fonction des capacités de l’agent client (par exemple, afficher une image, ouvrir un iframe, etc.)

À noter que le projet A2A est ouvert à la communauté : il est distribué sous licence Apache 2.0 et les contributions sont encouragées via le dépôt GitHub officiel. Des SDK sont d’ores et déjà disponibles en Python, Go, JavaScript, Java et .NET pour simplifier l’adoption du protocole par les développeurs.

Comment fonctionne le protocole Agent2Agent ?

Concrètement, un agent “client” initie la communication en formulant une tâche à accomplir, tandis qu’un agent “distant” (serveur) reçoit la demande et s’efforce de l’exécuter ou d’y répondre.

L’agent client agit donc au nom de l’utilisateur final (par exemple, un agent assistant qui reçoit une requête de l’utilisateur), et va déléguer le travail à un ou plusieurs agents distants spécialisés dans le domaine requis.

Assignation d’une tâche

Pour qu’un agent client puisse trouver le bon agent distant pour une tâche donnée, A2A prévoit un mécanisme de découverte des capacités. Chaque agent distant publie une carte d’identité appelée Agent Card (fichier JSON accessible à une URL bien connue, généralement /.well-known/agent.json).

Cette Agent Card décrit notamment : le nom et fournisseur du service, les versions supportées, les types de contenus en entrée/sortie, les méthodes d’authentification acceptées, ainsi que la liste des compétences de l’agent avec éventuellement des exemples.

En consultant ces cartes (manuellement ou via un registre/catalogue), un agent client peut identifier quel agent est le plus apte à traiter la tâche, puis initier la connexion vers cet agent via le protocole A2A.

Suivi de la tâche à réaliser

Une fois le bon agent distant sélectionné et l’authentification éventuellement établie, la communication s’articule autour d’un objet central : la Tâche (Task). Une tâche représente une unité de travail à réaliser (par ex. “traduire ce document” ou “récupérer les données client X”). Chaque tâche possède un identifiant unique et un état (soumise, en cours, en attente d’entrée, terminée, etc.) qui évolue au fil du processus

La définition standard de la tâche dans Agent2Agent facilite le suivi et la coordination, en particulier pour les workflows multi-étapes ou nécessitant une intervention humaine.

Une tâche est essentiellement une conversation structurée : elle contient une liste de Messages échangés et éventuellement des Artéfacts en sortie. Un message correspond à un tour de dialogue (question, réponse, clarification, etc.), et se compose d’un ou plusieurs Parts (morceaux de contenu autonome) comme du texte, un fichier binaire ou un bloc de données JSON.

Les artéfacts, quant à eux, sont les résultats concrets produits par l’agent distant (par exemple un document PDF généré, une image créée, un tableau de chiffres) ils peuvent aussi être constitués de parts multiples si nécessaire.

Le cycle de vie d’une interaction Agent2Agent

L’agent client envoie la tâche et son premier message (typiquement la demande de l’utilisateur) à l’agent distant.

L’agent distant traite la requête et peut répondre de plusieurs façons selon le contexte :

• soit fournir immédiatement un résultat final (artéfact)
• soit envoyer des messages intermédiaires (par ex. pour demander des précisions ou informer de l’avancement)
• soit indiquer qu’il a besoin d’une entrée supplémentaire de l’utilisateur (état “input-required”).

En cas de tâche longue, l’agent distant peut stocker l’état et streamer des mises à jour partielles via des événements server-sent (SSE) pour tenir l’agent client informé en temps réel. Et des mécanismes de reprises sont prévus en cas de perte de connexion entre les 2 agents.

Lorsque la tâche est achevée, l’agent distant envoie un message final (et éventuellement des artéfacts finaux). L’agent client peut alors marquer la tâche comme complétée et, le cas échéant, présenter le résultat à l’utilisateur ou enchaîner sur une autre action.

Ce fonctionnement orienté tâche et messages permet une coordination structurée mais flexible. Chaque agent impliqué reste maître de ses décisions internes, mais le protocole impose un format d’échange commun qui assure que tout le monde “se comprend”.

Cas d’usages concrets d’A2A

Un protocole d’interopérabilité tel que Agent2Agent ouvre la voie à de nombreux scénarios dans différents domaines. Voici quelques exemples concrets illustrant comment A2A peut être utilisé :

• Support IT autonome : imaginons un service helpdesk où des agents IA gèrent les tickets d’assistance technique. À la réception d’un ticket décrivant un problème (ex: « Mon ordinateur portable ne s’allume plus après la dernière mise à jour »), un agent de tri (agent client) peut orchestrer la résolution en mobilisant successivement plusieurs agents spécialisés via A2A.
  • Par exemple, l’agent client envoie d’abord une tâche à un agent diagnostic matériel pour vérifier l’état du device.
  • Si aucun problème physique n’est détecté, il sollicite alors un agent de restauration logicielle qui analyse les mises à jour récentes.
  • Si cela échoue, un agent de remplacement d’équipement est appelé pour initier un échange de l’ordinateur.
  • Chaque agent travaille indépendamment selon son domaine, et communique son progrès (log de diagnostic, résultat d’analyse, etc.) sous forme d’artéfacts ou de messages.

• Recrutement et ressources humaines : Google a illustré comment A2A peut simplifier le recrutement d’un développeur.
  • Un manager formule sa demande dans une interface unifiée : « Trouve-moi des candidats correspondant à tel poste, localisés à Paris avec telles compétences ».
  • Son agent personnel va alors interagir via A2A avec d’autres agents spécialisés : par exemple un agent chasseur de têtes qui interroge diverses bases de CV pour sourcer des profils adéquats.
  • L’agent recruteur renvoie ensuite une liste de candidats potentiels, que le manager peut affiner.
  • L’agent personnel peut alors contacter un agent planificateur pour organiser les entretiens avec les candidats retenus, puis éventuellement faire appel à un agent vérification pour lancer des vérifications de références ou de background une fois le candidat choisi.

De manière générale, dès qu’une tâche complexe peut être découpée en sous-tâches spécialisées, il est pertinent de déployer plusieurs agents qui coopèrent.

Par exemple, un utilisateur pourrait demander à un assistant IA : « Planifie-moi un voyage au meilleur prix ». L’agent assistant pourrait alors solliciter en parallèle un agent “vols” pour trouver des billets d’avion et un agent “hôtels” pour les hébergements, puis combiner les résultats et éventuellement faire appel à un agent “budget” pour optimiser le coût total. Ce type de workflow orchestré devient naturel avec A2A, chaque agent traitant une facette du problème et échangeant ses résultats avec l’agent orchestrateur.

Quelle est la différence entre A2A et MCP ?

A2A est souvent mentionné aux côtés de MCP, le Model Context Protocol introduit par Anthropic en 2024. Ces deux protocoles abordent des problématiques différentes mais complémentaires dans les systèmes d’agents IA. En simplifiant, on peut distinguer deux types d’interopérabilité dans le monde des agents :

• Interopérabilité avec les outils et services (MCP) – Le protocole MCP standardise la manière dont un agent peut utiliser des fonctions externes : appeler des API, accéder à des bases de données, déclencher des scripts ou utiliser des outils tierce partie. En somme, MCP sert d’interface entre les agents et l’ensemble des services structurés ou sources de données dont ils peuvent avoir besoin.
• Interopérabilité entre agents (A2A) – Le protocole A2A se concentre sur la communication directe entre agents eux-mêmes, sous forme de langage naturel ou d’échanges de données multimodales. Il établit les règles pour que deux agents (ou plus) puissent se coordonner en pair-à-pair et se passer le relais dans l’accomplissement d’une tâche complexe.

Conclusion

A2A s’impose comme une brique clé pour connecter des agents IA hétérogènes. Il fournit un cadre standardisé, sécurisé et flexible pour permettre leur coopération, quelle que soit leur origine technologique.

Conçu pour les environnements sensibles, A2A intègre nativement des mécanismes robustes d’authentification, d’autorisation et de chiffrement, inspirés des standards OAuth2/OpenID. Chaque échange entre agents est ainsi protégé, et aucune donnée sensible n’est exposée inutilement.

Pour les développeurs, c’est un levier d’orchestration multi-agent. Pour les entreprises, un moyen de décloisonner leurs systèmes IA tout en maîtrisant les risques de sécurité. Couplé à MCP, A2A prépare le terrain pour des écosystèmes d’agents intelligents, interopérables et fiables. Un standard à surveiller de près.