Protocole A2A : comment les agents IA communiquent entre eux

Votre assistant de programmation IA peut désormais interroger des bases de données, lire des fichiers et appeler des API grâce au protocole MCP. Mais que se passe-t-il quand cet assistant a besoin de l'aide d'un autre agent IA — un auditeur de sécurité, un spécialiste des tests ou un orchestrateur de déploiement ?

C'est exactement le problème que résout le protocole Agent2Agent (A2A). Lancé par Google en avril 2025 puis donné à la Linux Foundation, A2A est le standard ouvert qui permet aux agents IA de se découvrir mutuellement, de déléguer des tâches et de collaborer — quel que soit le framework ou le fournisseur qui les a construits.

Pourquoi les agents ont besoin de leur propre protocole

MCP a résolu le problème agent-outil. Un agent IA peut se connecter à GitHub, Slack ou une base de données via une interface universelle. Mais MCP traite chaque connexion comme un appel d'outil — il suppose un agent unique contrôlant des ressources passives.

Les flux de travail réels sont différents. Vous avez besoin d'un agent de recherche pour collecter les données, d'un agent financier pour les analyser et d'un agent de reporting pour tout synthétiser en document. Ces agents ne sont pas des outils passifs. Ce sont des systèmes autonomes avec leurs propres capacités, état et logique de décision.

Avant A2A, connecter des agents signifiait construire des intégrations personnalisées pour chaque paire. L'agent A parle LangChain. L'agent B tourne sur CrewAI. L'agent C est un système propriétaire. Les faire collaborer nécessitait de construire des ponts entre chaque framework — des ponts qui se brisaient à chaque mise à jour.

A2A élimine cette fragmentation en fournissant un protocole unique pour la communication inter-agents, de la même manière que HTTP a standardisé la communication web il y a des décennies.

Comment fonctionne A2A

Le protocole est construit sur des standards web familiers : transport HTTP/HTTPS, sérialisation JSON et Server-Sent Events (SSE) pour le streaming en temps réel. La version 0.3 ajoute également le support gRPC pour les scénarios à haut débit.

Agent Cards : identité lisible par les machines

Chaque agent compatible A2A publie un document JSON à l'adresse /.well-known/agent.json. Cette carte d'agent déclare son identité, ses capacités et ses méthodes d'authentification :

{
  "name": "Code Review Agent",
  "description": "Examine les pull requests pour les vulnérabilités et la qualité du code",
  "url": "https://api.example.com/agent",
  "version": "1.0.0",
  "authentication": {
    "schemes": ["OAuth2", "Bearer"]
  },
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  }
}

Les agents clients interrogent ces cartes pour évaluer la compatibilité avant de déléguer du travail. Aucune intégration codée en dur nécessaire — la découverte se fait dynamiquement à l'exécution.

Cycle de vie des tâches

A2A définit six états pour gérer le travail :

1. submitted — tâche acceptée, en file d'attente
2. working — traitement actif avec mises à jour optionnelles via SSE
3. input-required — agent en pause, demande des données supplémentaires ou une autorisation humaine
4. completed — fin réussie avec résultats typés
5. failed — erreur avec diagnostics détaillés
6. cancelled — annulation par le client ou le serveur

L'état input-required est particulièrement important. Il permet aux agents de demander une intervention humaine sans interrompre le flux — un agent peut se mettre en pause, demander une approbation, puis reprendre une fois autorisé.

Flux de communication

La soumission de tâches utilise des endpoints HTTP standards :

Les résultats sont retournés sous forme d'artefacts typés avec types MIME et métadonnées, supportant données en ligne et références externes. Les agents peuvent ainsi échanger textes, JSON, fichiers, images ou tout autre type de contenu.

A2A + MCP : la pile complète des agents

Ces deux protocoles ne sont pas concurrents — ce sont des couches complémentaires :

• MCP connecte les agents aux outils et données (bases de données, API, systèmes de fichiers)
• A2A connecte les agents à d'autres agents (délégation, collaboration, orchestration)

Dans un système sophistiqué, les deux coexistent. Un agent orchestrateur utilise A2A pour déléguer une tâche de recherche à un agent spécialisé. Cet agent utilise en interne MCP pour se connecter aux outils de recherche et bases de données. Les résultats reviennent via A2A sous forme d'artefacts typés.

Pensez-y ainsi : MCP, ce sont les mains de l'agent (comment il interagit avec le monde). A2A, c'est sa voix (comment il se coordonne avec ses pairs).

Architecture en conditions réelles

Voici à quoi ressemble un flux de travail multi-agents en entreprise avec A2A :

Escalade du support client :

1. Un agent de triage reçoit une demande client via A2A
2. Il interroge un registre de cartes d'agents pour trouver un spécialiste facturation
3. Il délègue l'investigation via /tasks/send
4. L'agent facturation utilise MCP en interne pour interroger la base de paiements
5. Si un remboursement est nécessaire, il délègue à un agent de traitement via A2A
6. Chaque agent rapporte son statut via streaming SSE
7. L'agent de triage synthétise tous les artefacts en une réponse client

Pipeline de développement :

1. Un orchestrateur reçoit une notification de changement de code
2. Il délègue la revue de code à un agent de sécurité via A2A
3. Simultanément, il délègue les tests à un agent QA
4. Les deux agents utilisent des outils MCP en interne
5. Les résultats reviennent comme artefacts (commentaires de revue, rapports de tests)
6. L'orchestrateur prend la décision de merge sur la base des résultats combinés

Modèle de sécurité

A2A hérite des standards de sécurité web plutôt que d'en inventer de nouveaux :

• OAuth 2.0, clés API et tokens de compte de service pour l'authentification
• HTTPS/TLS obligatoire pour le chiffrement du transport
• Identifiants propres à chaque agent pour les flux inter-organisations, évitant les problèmes d'escalade de privilèges
• Journaux d'audit HTTP intégrés aux infrastructures de surveillance existantes

Chaque agent opère avec sa propre identité et ses propres permissions. Quand l'agent A délègue à l'agent B, l'agent B utilise ses propres identifiants pour accéder aux ressources — pas ceux de l'agent A.

Adoption de l'écosystème

A2A a été lancé avec plus de 50 partenaires technologiques dont Salesforce, SAP, ServiceNow, Workday, Atlassian, MongoDB, LangChain et CrewAI. Les grands cabinets de conseil — Deloitte, Accenture, McKinsey, PwC — développent des implémentations entreprise.

Le protocole a été donné à la fondation Agentic AI de la Linux Foundation en décembre 2025, aux côtés de MCP, consolidant les deux comme standards industriels neutres.

Le support SDK est disponible en Python et Node.js, avec des implémentations communautaires émergentes en Go, Rust et Java.

Limitations actuelles

A2A est encore en maturation. Les principales lacunes :

• Pas de registre centralisé — les équipes gèrent leurs propres répertoires d'agents
• Pas de mécanisme de versioning standard pour les changements de capacités
• Pas d'intégration de facturation — les déclarations de prix existent mais manquent de métrologie standardisée
• Le traçage distribué nécessite une corrélation manuelle par identifiant de tâche

Ce sont des problèmes d'infrastructure, pas des problèmes de protocole. Avec la croissance de l'adoption, attendez-vous à voir émerger des registres, des outils d'observabilité et des couches de facturation — comme l'écosystème Docker a construit registres et monitoring autour des standards de conteneurs.

Démarrer

Si vous construisez des systèmes multi-agents, l'adoption d'A2A est simple :

1. Exposez une carte d'agent à /.well-known/agent.json décrivant les capacités de votre agent
2. Implémentez les endpoints de tâches (/tasks/send, /tasks/sendSubscribe) au format JSON-RPC
3. Retournez des artefacts typés avec les types MIME appropriés
4. Ajoutez le streaming SSE pour les tâches longues

Le SDK Python fournit une implémentation de référence :

from a2a.client import A2AClient
 
client = A2AClient("http://code-review-agent:8000")
task = await client.send_task({
    "message": {
        "role": "user",
        "content": "Examiner la PR #142 pour les problèmes de sécurité"
    }
})
 
async for update in client.subscribe(task["id"]):
    print(update)

La vision globale

MCP a donné aux agents IA des mains pour interagir avec les outils. A2A leur donne la capacité de collaborer avec leurs pairs. Ensemble, ils forment l'épine dorsale de la communication dans l'ère de l'IA agentique — où le logiciel n'est plus une application monolithique mais un réseau d'agents spécialisés coordonnés en temps réel.

Pour les développeurs et entreprises de la région MENA qui construisent des systèmes IA natifs, comprendre ces protocoles n'est pas optionnel. Ils deviennent le HTTP et le TCP/IP de l'économie des agents. Les organisations qui les adoptent tôt auront l'architecture pour passer à l'échelle quand les flux multi-agents deviendront la norme — et non l'exception.