Dépôts GitHub & Spécifications Officielles :
• MCP : https://github.com/modelcontextprotocol/modelcontextprotocol
• A2A : https://github.com/a2aproject/A2A (et archive IBM ACP : https://github.com/i-am-bee/acp)
• AG-UI : https://github.com/ag-ui-protocol/ag-ui (et Google A2UI : https://github.com/google/A2UI)

Les infographies qui circulent sur l’écosystème des agents IA résument volontiers l’architecture en trois boîtes propres : MCP (« créé par Anthropic, maintenu par une fondation ») pour connecter l’agent à ses outils, A2A (« créé par Google, donné à la Linux Foundation ») pour faire dialoguer les agents entre eux, et AG-UI (« intégré aux grands frameworks ») pour relier l’agent à l’interface utilisateur.

Si ce découpage fonctionnel en trois plans est un bon point de départ, ses raccourcis institutionnels masquent l’essentiel :

1. Un transfert à la Linux Foundation ne produit pas un modèle unique de gouvernance : bien qu’hébergés tous deux sous l’ombrelle juridique LF Projects, LLC, MCP et A2A ont adopté des chartes de pouvoir radicalement opposées (modèle BDFL méritocratique individuel sans siège d’entreprise pour MCP, contre comité directeur TSC à sièges réservés par grandes entreprises pour A2A).
2. Certains protocoles présentés comme concurrents ont en réalité fusionné (comme ACP d’IBM Research absorbé par A2A en août 2025), tandis que d’autres opèrent à des sous-couches différentes de la pile frontend (AG-UI pour le flux d’événements SSE temps réel, A2UI pour la charge utile JSON déclarative de composants, et MCP Apps pour les iframes sandboxées).
3. La mention « intégré à un framework » recouvre quatre niveaux de maturité très hétérogènes, allant du SDK natif maintenu par l’éditeur (Microsoft, AWS) jusqu’au simple ticket GitHub « In Progress ».

Cet article articule l’architecture technique détaillée de chaque protocole avec l’examen critique et sourcé de leur histoire institutionnelle (2024–2026). Chaque événement clé est accompagné en texte intégral de sa date d’événement, de la date de publication de sa source primaire (lorsqu’elle diffère), du titre exact du document officiel et de son URL complète pour vérification directe.

Vue d’ensemble : La pile protocolaire d’un système multi-agents en production

Avant de déconstruire les mythes institutionnels, posons la topologie technique exacte des flux dans une architecture agentique complète :

┌──────────────────────────────────────────────────────────────────────────────┐
│                        INTERFACE UTILISATEUR (FRONTEND)                      │
│  Application Web / Mobile / IDE (React, Next.js, Flutter, Angular, Lit)      │
│  • Rendu déclaratif natif via catalogue hôte : A2UI (application/a2ui+json)  │
│  • Ou composant interactif isolé en iframe   : MCP Apps (ui://)              │
└──────────────────────────────────────▲───────────────────────────────────────┘
                                       │
                                       │ 1. Plan Agent <-> Humain : AG-UI
                                       │    Flux SSE / Binaire bidirectionnel
                                       │    (RUN_STARTED, TEXT_MESSAGE_CONTENT,
                                       │     TOOL_CALL_START, STATE_DELTA RFC 6902,
                                       │     Interruptions Human-in-the-Loop)
                                       ▼
┌──────────────────────────────────────────────────────────────────────────────┐
│                         AGENT ORCHESTRATEUR PRINCIPAL                        │
│  Exécuté sur LangGraph, Microsoft Agent Framework, Google ADK, CrewAI, etc.  │
└───────────────┬──────────────────────────────────────────────┬───────────────┘
                │                                              │
                │ 2. Plan Vertical (Agent <-> Outils) : MCP    │ 3. Plan Horizontal (Agent <-> Agent) : A2A
                │    JSON-RPC 2.0 sur stdio ou Streamable HTTP │    Découverte (/.well-known/agent-card.json)
                │    OAuth 2.1 + RFC 8707 Resource Indicators  │    Tâches asynchrones longues (Task, Artifact)
                │    Primitives : Tools, Resources, Prompts,   │    Bindings HTTP / JSON-RPC / gRPC / REST
                │    Sampling, Elicitation, Tasks (SEP-1686)   │    Signed Agent Cards (v1.0)
                ▼                                              ▼
┌───────────────────────────────────────┐      ┌───────────────────────────────────────┐
│     SERVEURS MCP (OUTILS & DONNÉES)   │      │    AGENTS DISTANTS OPAQUES (TIERS)    │
│  Bases SQL, Git, API métier, fichiers │      │  Agent SAP, Agent ServiceNow,         │
│  (Contexte et exécution déterministe) │      │  Agent BeeAI / IBM, Agent Salesforce  │
└───────────────────────────────────────┘      └───────────────────────────────────────┘

1. A2A (Agent2Agent) : De l’initiative Google Cloud au comité TSC de la Linux Foundation

1.1. Fonctionnement technique d’A2A : pourquoi MCP ne suffit pas entre deux agents

Lorsqu’un agent orchestre un outil via MCP, cet outil est une fonction déterministe dotée d’entrées typées (tools/call). Or, déléguer une mission complexe à un autre agent autonome (par exemple, un agent d’achat interrogeant un agent financier SAP et un agent juridique ServiceNow) pose trois problèmes que MCP n’avait pas vocation à résoudre à l’origine :

1. L’opacité nécessaire (Opaque Execution) : Deux agents appartenant à des départements ou à des entreprises différentes ne doivent pas exposer leurs prompts système, leur graphe de raisonnement interne ni leurs clés d’outils respectives.
2. La négociation dynamique de capacités et de modalités : Via le manifeste standardisé Agent Card exposé sur /.well-known/agent-card.json, chaque agent publie ses compétences (skills), ses exigences d’authentification et ses modalités d’entrée/sortie supportées (texte, formulaires structurés, flux audio/vidéo). Depuis A2A v1.0.0 (12 mars 2026), ces cartes peuvent être signées cryptographiquement (Signed Agent Cards) pour prévenir l’usurpation d’identité d’agent.
3. Le cycle de vie des tâches longues (Task & Artifact) : Une tâche inter-agents peut durer plusieurs secondes ou plusieurs jours, passer par des états submitted, working, input-required (lorsque l’agent distant demande une clarification à l’agent appelant), completed, failed ou canceled, et émettre des mises à jour incrémentales via SSE ou des notifications push (webhooks).

1.2. Déconstruction institutionnelle n°1 : « A2A a été créé par Google et est maintenu par la Linux Foundation »

1. L’affirmation simplifiée

« A2A a été créé par Google et est aujourd’hui maintenu de manière indépendante par la Linux Foundation. »

2. Ce qu’elle a de juste et ce qu’elle masque

• Qui a initié et conçu le protocole : La conception initiale a bien été pilotée en interne chez Google Cloud (avec un rôle d’architecte principal tenu par Todd Segal, Principal/Distinguished Engineer chez Google Cloud, aux côtés de Rao Surapaneni, Miku Jha et Michael Vakoc).
• Qui a contribué à son développement initial et qui l’a annoncé : Contrairement à un projet développé en vase clos puis publié seul, Google a co-construit le lancement avec plus de 50 partenaires technologiques (dont Atlassian, Box, Cohere, Intuit, LangChain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, UKG et Workday) et plus de 12 grands intégrateurs et cabinets de conseil (Accenture, BCG, Capgemini, Cognizant, Deloitte, HCLTech, Infosys, KPMG, McKinsey, PwC, TCS, Wipro).
• Qui en assurait la gouvernance au lancement : D’avril à juin 2025, le dépôt GitHub (google/A2A, transféré ensuite vers a2aproject/A2A) était placé sous la responsabilité directe de Google sous licence Apache 2.0.
• Qui en assure la gouvernance aujourd’hui (et ce que masque le mot « fondation ») : Le projet est juridiquement hébergé par la Linux Foundation (The Agent2Agent Project a Series of LF Projects, LLC), mais sa gouvernance technique repose durant sa phase de démarrage de 18 mois sur un Technical Steering Committee (TSC) composé de sièges attribués à des entreprises nommées, et non sur une élection ouverte de mainteneurs individuels.

3. Chronologie reconstituée et vérifiée sur sources primaires

• Événement 1 : Lancement public et publication de la spécification initiale d’A2A :

  • Date de l’événement : 9 avril 2025 (lors de Google Cloud Next ‘25) : Date de publication de la source : 9 avril 2025.
  • Fait précis et acteurs : Rao Surapaneni, Miku Jha, Michael Vakoc et Todd Segal (Google Cloud) annoncent l’ouverture du protocole A2A avec le soutien de plus de 50 partenaires technologiques et 12 sociétés de services.
  • Nuance apportée : Dès le premier jour, A2A est présenté comme un effort de coalition industrielle complétant explicitement le protocole MCP d’Anthropic (« A2A is an open protocol that complements Anthropic’s Model Context Protocol (MCP) »).
  • Source officielle : « Announcing the Agent2Agent Protocol (A2A) » : Google Developers Blog : https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/

• Événement 2 : Annonce contemporaine du transfert d’A2A à la Linux Foundation :

  • Date de l’événement : 23 juin 2025 (lors de l’Open Source Summit North America à Denver) : Date de publication des sources : 23 juin 2025.
  • Fait précis et acteurs : La Linux Foundation et Google Cloud annoncent la création officielle du projet Agent2Agent au sein de la Linux Foundation, avec la donation par Google de la spécification, des SDK et des outils associés. Sept entreprises fondatrices structurent cette entrée : AWS, Cisco, Google, Microsoft, Salesforce, SAP et ServiceNow, entourées de plus de 100 entreprises soutenant l’initiative.
  • Nuance apportée : Consulter l’annonce contemporaine du 23 juin 2025 (plutôt que la seule rétrospective d’avril 2026) permet de constater que l’entrée d’AWS et de Microsoft comme membres fondateurs aux côtés de Google a été actée seulement 75 jours après l’annonce initiale d’A2A.
  • Sources officielles contemporaines :
    1. « Linux Foundation Launches the Agent2Agent Protocol Project to Enable Secure, Intelligent Communication Between AI Agents » (23 juin 2025) : https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents
    2. « Google Cloud donates A2A to Linux Foundation » (23 juin 2025, Google Developers Blog) : https://developers.googleblog.com/en/google-cloud-donates-a2a-to-linux-foundation/

• Événement 3 : Charte de gouvernance effective (GOVERNANCE.md) :

  • Date du document : En vigueur depuis l’entrée sous LF Projects, LLC (révision active dans la branche main en 2025–2026).
  • Fait précis et acteurs : La charte institue une « Startup Phase » de 18 mois durant laquelle le comité technique (TSC) est constitué d’un représentant votant désigné par chacune des entreprises membres de la liste fermée, toute admission d’une nouvelle entreprise nécessitant un vote majoritaire du TSC existant. Les 9 entreprises détenant un siège votant au TSC sont : Google (Todd Segal), Microsoft (Darrel Miller), Cisco (Luca Muscariello), AWS (Abhimanyu Siwach), Salesforce (Stephen Petschulat), ServiceNow (Sugandh Rakha), SAP (Sivakumar N.), IBM (Stefano Maestri) et Bloomberg (Vinay Ramesh).
  • Nuance apportée : Le transfert à la Linux Foundation garantit la neutralité de la propriété intellectuelle (marque, licence Apache 2.0, absence de contrôle unilatéral par Google seul), mais le pouvoir décisionnel est détenu par un directoire de 9 grands éditeurs cloud/entreprise jusqu’au passage prévu vers une gouvernance « Steady State » au bout de 18 mois.
  • Source officielle : « Agent2Agent Project Governance (GOVERNANCE.md) » : Dépôt officiel GitHub a2aproject/A2A : https://github.com/a2aproject/A2A/blob/main/GOVERNANCE.md

• Événement 4 : Publication d’A2A v1.0.0, rétrospective d’un an et correctif v1.0.1 :

  • Dates exactes des événements vs dates de publication :
    • Publication technique du tag v1.0.0 sur GitHub : 12 mars 2026 (2026-03-12).
    • Publication du billet rétrospectif officiel du 1er anniversaire : 16 avril 2026 (qui célèbre l’anniversaire du lancement du 9 avril 2025 et mentionne la sortie de la v1.0 intervenue « en mars » sans préciser le quantième).
    • Publication technique du tag v1.0.1 sur GitHub : 26 mai 2026 (2026-05-26, recommandant le type MIME application/a2a+json).
  • Fait précis et acteurs : La version v1.0.0 stabilise les bindings multi-protocoles (JSON-RPC, gRPC, REST), introduit les Signed Agent Cards et inscrit A2A dans une famille de standards associés baptisée « A2Family » (AP2 pour les paiements d’agents, A2UI pour les interfaces, UCP).
  • Sources officielles :
    1. « A year of open collaboration: Celebrating the anniversary of A2A » (publié le 16 avril 2026, Google Open Source Blog) : https://opensource.googleblog.com/2026/04/a-year-of-open-collaboration-celebrating-the-anniversary-of-a2a.html
    2. « A2A GitHub Releases (v1.0.0 - 12 mars 2026 / v1.0.1 - 26 mai 2026) » : https://github.com/a2aproject/A2A/releases

4. Pourquoi cette évolution compte

• Motivations explicitement annoncées par les acteurs : Google Cloud et la Linux Foundation expliquent que le transfert rapide (en moins de trois mois) visait à garantir une gouvernance neutre (vendor-neutral), éviter la fragmentation des standards d’entreprise et rassurer les grands comptes sur la pérennité d’Apache 2.0.
• Analyse architecturale et institutionnelle : En acceptant de partager le TSC à égalité de voix (1 entreprise = 1 siège) avec AWS, Microsoft, IBM, Cisco, SAP, Salesforce, ServiceNow et Bloomberg, Google a renoncé au contrôle exclusif de son protocole en échange d’un effet de réseau décisif : empêcher l’émergence d’un protocole concurrent chez AWS ou Microsoft et absorber celui d’IBM. En revanche, qualifier cette gouvernance de « communautaire » sans précision serait trompeur : dans sa phase initiale de 18 mois, A2A est un consortium d’éditeurs enterprise sous l’arbitrage juridique de la Linux Foundation.

5. Formulation exacte et réutilisable

Formulation exacte : « Initié chez Google Cloud et annoncé le 9 avril 2025 avec plus de 50 partenaires, A2A a été transféré le 23 juin 2025 à la Linux Foundation. Dire “créé par Google et maintenu par une fondation” résume son origine mais occulte sa gouvernance réelle : le protocole est aujourd’hui piloté par un comité technique (TSC) où 9 grands groupes (Google, Microsoft, AWS, Cisco, Salesforce, ServiceNow, SAP, IBM et Bloomberg) détiennent chacun un siège votant. »

2. La fusion d’ACP (IBM Research / BeeAI) dans A2A : la consolidation du plan Agent-à-Agent

2.1. Déconstruction institutionnelle n°2 : « ACP et A2A sont deux protocoles concurrents »

1. L’affirmation simplifiée

« Pour la communication inter-agents, l’écosystème hésite entre deux standards concurrents : A2A de Google et ACP (Agent Communication Protocol) d’IBM. »

2. Ce qu’elle a de juste et ce qu’elle masque

• Ce qu’elle avait de juste au printemps 2025 : Au premier semestre 2025, IBM Research a effectivement conçu et lancé ACP (Agent Communication Protocol) pour alimenter sa plateforme open source BeeAI, quelques semaines avant l’annonce d’A2A par Google.
• Ce qu’elle masque aujourd’hui : Cette concurrence est terminée depuis le 25 août 2025. Les équipes d’IBM Research et d’A2A ont fusionné leurs efforts sous l’égide de la Linux Foundation : le développement autonome d’ACP est arrêté, le dépôt i-am-bee/acp est archivé en faveur d’A2A, BeeAI a migré nativement sur A2A, et IBM a obtenu un siège votant au TSC d’A2A.

3. Chronologie reconstituée et vérifiée sur sources primaires

• Événement 1 : Lancement d’ACP par IBM Research et donation de BeeAI à la Linux Foundation :

  • Date de l’événement : Mars 2025 (note méthodologique : la source primaire officielle d’IBM situe le lancement initial d’ACP et sa donation avec BeeAI à la Linux Foundation « en mars 2025 » sans mentionner un jour calendaire unique ; nous conservons donc strictement la précision mensuelle « mars 2025 ») : Date de publication de la source récapitulative : 25 août 2025.
  • Fait précis et acteurs : IBM Research lance ACP pour interconnecter des agents construits sur des frameworks hétérogènes au sein de BeeAI, puis fait don de BeeAI et d’ACP à la Linux Foundation.
  • Source officielle : « ACP Joins Forces with A2A Under the Linux Foundation · i-am-bee · Discussion #5 » : https://github.com/orgs/i-am-bee/discussions/5

• Événement 2 : Fusion officielle d’ACP dans A2A et arrêt du développement d’ACP :

  • Date de l’événement : 25 août 2025 : Date de publication de la source : 25 août 2025.
  • Fait précis et acteurs : Kate Blair (@geneknit, Director of Incubation for IBM Research) annonce officiellement que l’équipe ACP rejoint A2A au sein de la Linux Foundation. Le dépôt i-am-bee/acp cesse tout développement actif, la plateforme BeeAI remplace ses classes par les adaptateurs A2AServer et A2AAgent, et Stefano Maestri (IBM) intègre le TSC d’A2A.
  • Nuance apportée : Ce n’est pas une disparition sèche sans héritage technique : l’expérience d’IBM sur le routage léger REST/HTTP, la télémétrie d’agents et l’ergonomie de déploiement local (BeeAI) a directement alimenté la feuille de route d’A2A vers sa v1.0.
  • Sources officielles :
    1. « ACP Joins Forces with A2A Under the Linux Foundation · i-am-bee · Discussion #5 » (25 août 2025) : https://github.com/orgs/i-am-bee/discussions/5
    2. « Agent Communication Protocol (ACP) Repository README » : https://github.com/i-am-bee/acp

4. Pourquoi cette évolution compte

• Motivations explicitement annoncées par les acteurs : Kate Blair (IBM Research) écrit que maintenir deux protocoles poursuivant exactement la même mission au sein de la même fondation (Linux Foundation) fragmenterait inutilement les efforts des développeurs (« Rather than fragmenting efforts across two protocols with the same mission, we’re combining our expertise »).
• Analyse architecturale et institutionnelle : Cette fusion prouve le rôle d’amortisseur diplomatique de la Linux Foundation. Dès lors qu’IBM et Google avaient tous deux placé leurs projets sous LF Projects, LLC, la convergence devenait rationnelle : IBM sécurise un siège de co-décision au TSC d’A2A et évite d’isoler BeeAI, tandis qu’A2A devient le standard horizontal incontesté.

5. Formulation exacte et réutilisable

Formulation exacte : « Lancé par IBM Research en mars 2025 pour la plateforme BeeAI, le protocole ACP ne concurrencie plus A2A : le 25 août 2025, IBM a officiellement fusionné ACP dans A2A au sein de la Linux Foundation, migré BeeAI vers A2A et rejoint le comité directeur (TSC) d’A2A. »

3. MCP (Model Context Protocol) : Évolutions de la spécification et gouvernance BDFL au sein de l’AAIF

3.1. Fonctionnement technique et ruptures majeures de la spécification MCP (2024–2025)

Conçu pour remplacer la matrice $M \times N$ de connecteurs ad hoc entre modèles et sources de données, MCP repose sur JSON-RPC 2.0 et expose trois primitives serveur (Resources pour les données lues, Prompts pour les gabarits d’interaction, Tools pour les actions exécutables) et deux primitives client (Sampling permettant au serveur de demander une complétion LLM au client, et Roots).

Mais l’erreur fréquente consiste à décrire MCP tel qu’il fonctionnait en novembre 2024. Trois révisions majeures ont profondément transformé son architecture en 2025 :

1. Remplacement du transport HTTP+SSE par Streamable HTTP (26 mars 2025) : La version initiale 2024-11-05 imposait deux points de terminaison couplés en permanence (un flux SSE entrant dédié + un endpoint HTTP POST), ce qui compliquait le passage à l’échelle sans état (stateless) et les proxys d’entreprise. La révision 2025-03-26 introduit Streamable HTTP (PR #206) : un endpoint HTTP unique (/mcp) où une requête POST peut recevoir soit une réponse JSON immédiate, soit être promue dynamiquement en flux SSE, tout en permettant des serveurs MCP purement stateless.
2. Durcissement OAuth 2.1, Resource Indicators (RFC 8707) et suppression du batching (18 juin 2025) : La révision 2025-06-18 qualifie formellement les serveurs MCP d’OAuth 2.1 Resource Servers (PR #338), rend obligatoire l’usage des Resource Indicators (RFC 8707) (PR #734) pour empêcher le détournement de jetons d’un serveur MCP vers un autre, supprime le batching JSON-RPC (PR #416), et ajoute la primitive Elicitation (PR #382), permettant à un serveur MCP de demander directement des informations structurées (schéma JSON) à l’utilisateur pendant l’exécution d’un outil.
3. Tâches durables asynchrones (SEP-1686), OIDC Discovery et protection Origin (25 novembre 2025) : La révision 2025-11-25 (1er anniversaire de MCP) introduit la primitive expérimentale Tasks (SEP-1686) pour le suivi d’exécutions longues côté serveur MCP, l’appel d’outils à l’intérieur du Sampling (SEP-1577), l’élicitation par URL sécurisée (SEP-1036, pour les flux OAuth ou paiements tiers hors bande), et impose le rejet par HTTP 403 de toute requête Streamable HTTP présentant un en-tête Origin invalide (PR #1439 contre le DNS rebinding).

3.2. Déconstruction institutionnelle n°3 : « MCP a été créé par Anthropic puis confié à une fondation »

1. L’affirmation simplifiée

« MCP a été créé par Anthropic en novembre 2024, puis transféré à la Linux Foundation en décembre 2025 où il est désormais gouverné comme A2A. »

2. Ce qu’elle a de juste et ce qu’elle masque

• Qui a initié et conçu le protocole : MCP a été co-inventé en interne chez Anthropic par David Soria Parra et Justin Spahr-Summers.
• Qui a contribué au lancement : Lors de l’annonce du 25 novembre 2024, Block et Apollo figuraient parmi les premiers intégrateurs entreprise, accompagnés des éditeurs d’outils de développement Zed, Replit, Codeium et Sourcegraph.
• Ce que masque le transfert à la fondation du 9 décembre 2025 :
  1. MCP n’a pas simplement été donné isolément : Anthropic, Block et OpenAI se sont alliés pour fonder ensemble l’Agentic AI Foundation (AAIF) au sein de la Linux Foundation, en y apportant trois piliers fondateurs : MCP (par Anthropic), le framework d’agent local goose (par Block) et le standard AGENTS.md (par OpenAI).
  2. Surtout, le transfert à l’AAIF n’a PAS remplacé la gouvernance technique de MCP par un comité d’entreprises. Le communiqué d’Anthropic du 9 décembre 2025 précise explicitement : « The Model Context Protocol’s governance model will remain unchanged ». Contrairement à A2A, la charte de gouvernance de MCP interdit les sièges réservés aux entreprises et repose sur un modèle hiérarchique individuel de type BDFL (Benevolent Dictator For Life) détenu par les Lead Maintainers.

3. Chronologie reconstituée et vérifiée sur sources primaires

• Événement 1 : Tag initial de la spécification (2024-11-05) et annonce publique de MCP (25 novembre 2024) :

  • Date du tag de spécification initiale : 5 novembre 2024 (2024-11-05) : Date de l’annonce publique et de publication de la source : 25 novembre 2024.
  • Fait précis et acteurs : Anthropic publie en open source la spécification MCP, les SDK Python/TypeScript et les serveurs de référence, avec des intégrations initiales chez Block, Apollo, Zed, Replit, Codeium et Sourcegraph.
  • Source officielle : « Introducing the Model Context Protocol » (25 novembre 2024, Anthropic News) : https://www.anthropic.com/news/model-context-protocol

• Événement 2 : Les trois révisions structurantes de la spécification MCP en 2025 :

  • Dates d’événements et de publication : 26 mars 2025, 18 juin 2025 et 25 novembre 2025.
  • Faits précis : Passage à Streamable HTTP et OAuth 2.1 (2025-03-26), RFC 8707 Resource Indicators et Elicitation (2025-06-18), puis Tasks durables SEP-1686 et Sampling avec outils SEP-1577 (2025-11-25).
  • Sources officielles :
    1. « Key Changes - Version 2025-03-26 » : https://modelcontextprotocol.io/specification/2025-03-26/changelog
    2. « Key Changes - Version 2025-06-18 » : https://modelcontextprotocol.io/specification/2025-06-18/changelog
    3. « Key Changes - Version 2025-11-25 » : https://modelcontextprotocol.io/specification/2025-11-25/changelog

• Événement 3 : Création de l’Agentic AI Foundation (AAIF) sous la Linux Foundation et donation de MCP :

  • Date de l’événement : 9 décembre 2025 : Date de publication des sources : 9 décembre 2025.
  • Fait précis et acteurs : La Linux Foundation annonce la création de l’Agentic AI Foundation (AAIF), co-fondée par Anthropic, Block et OpenAI, qui lui transfèrent respectivement MCP, goose et AGENTS.md. Les membres Platinum de l’AAIF à sa création sont AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft et OpenAI.
  • Nuance apportée : Voir Anthropic, OpenAI et Google siéger ensemble comme membres Platinum de l’AAIF marque l’adoption universelle de MCP par les fournisseurs de modèles concurrents d’Anthropic, tout en séparant le financement de la fondation (géré par le Governing Board de l’AAIF) de la direction technique du protocole.
  • Sources officielles :
    1. « Donating the Model Context Protocol and establishing the Agentic AI Foundation » (9 décembre 2025, Anthropic News) : https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation
    2. « Linux Foundation Announces the Formation of the Agentic AI Foundation (AAIF), Anchored by New Project Contributions Including Model Context Protocol (MCP), goose and AGENTS.md » (9 décembre 2025, Linux Foundation Press) : https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation

• Événement 4 : Charte de gouvernance technique de MCP (Modèle BDFL individuel) :

  • Date du document : Charte en vigueur sur modelcontextprotocol.io (maintenue après l’entrée dans l’AAIF le 9 décembre 2025).
  • Fait précis et acteurs : La charte stipule explicitement : « Membership in the technical governance process is for individuals, not companies; there are no seats reserved for specific companies » et « MCP currently operates under a hierarchical BDFL (Benevolent Dictator For Life) model ». Les Lead Maintainers détiennent l’autorité finale et un droit de veto sur les décisions des Core Maintainers et sur le processus de Specification Enhancement Proposals (SEPs). Les deux Lead Maintainers en exercice sont David Soria Parra (Co-inventeur, Anthropic) et Den Delimarsky (Microsoft), tandis que Justin Spahr-Summers (Co-inventeur) a le statut Emeritus.
  • Source officielle : « Governance and Dual-Process Stewardship : Model Context Protocol » : https://modelcontextprotocol.io/community/governance

4. Pourquoi cette évolution compte : Comparaison directe des gouvernances MCP vs A2A

• Motivations explicitement annoncées par les acteurs : Anthropic souligne qu’en donnant MCP à l’AAIF aux côtés d’OpenAI et de Block tout en maintenant les mainteneurs existants aux commandes techniques, le projet garantit à la fois une neutralité juridique absolue et la cohérence architecturale rapide qui a fait son succès.
• Analyse institutionnelle comparée : Bien que MCP et A2A affichent tous deux le pied de page légal « a Series of LF Projects, LLC », leurs mécanismes de pouvoir sont à l’opposé l’un de l’autre :

5. Formulation exacte et réutilisable

Formulation exacte : « Initié par David Soria Parra et Justin Spahr-Summers chez Anthropic et annoncé le 25 novembre 2024 (spécification initiale 2024-11-05), MCP a été transféré le 9 décembre 2025 à l’Agentic AI Foundation (AAIF, co-fondée sous la Linux Foundation par Anthropic, Block et OpenAI). Contrairement à A2A, ce transfert n’a pas instauré de comité par sièges d’entreprises : MCP conserve une gouvernance technique individuelle de type BDFL dirigée par ses Lead Maintainers (David Soria Parra chez Anthropic et Den Delimarsky chez Microsoft). »

4. AG-UI, A2UI et MCP Apps : La couche d’interaction Agent ↔ Humain décortiquée

4.1. Fonctionnement technique : pourquoi le dernier kilomètre vers l’humain exige un protocole dédié

Connecter un agent à ses outils (MCP) et à d’autres agents (A2A) laisse entier le problème du dernier kilomètre vers l’utilisateur final. Un agent qui collabore avec un humain dans une interface moderne ne se contente pas d’envoyer des blocs de texte Markdown façon ChatGPT :

• Il doit diffuser en temps réel son cycle d’exécution (RUN_STARTED, STEP_STARTED, TEXT_MESSAGE_CONTENT), afficher les appels d’outils en cours (TOOL_CALL_START, TOOL_CALL_ARGS, TOOL_CALL_END), synchroniser un état applicatif partagé avec le frontend via des patchs JSON incrémentaux (RFC 6902 JSON Patch dans STATE_DELTA après un STATE_SNAPSHOT), et mettre son exécution en pause pour attendre une validation humaine (Human-in-the-Loop). C’est exactement le rôle du flux d’événements AG-UI.
• Mais lorsque l’agent souhaite générer dynamiquement une interface graphique riche (un formulaire de réservation, un tableau comparatif interactif, un sélecteur de créneaux) sans que le frontend ait codé cet écran à l’avance, deux approches complémentaires coexistent :
  1. A2UI (Agent-to-User Interface, initié par Google) : L’agent envoie une description JSON purement déclarative (application/a2ui+json) d’un arbre de composants abstraits (Card, Button, TextField, liés à un DataModel). L’application cliente traduit ces identifiants vers ses propres composants natifs (React, Angular, Lit, Flutter) issus d’un catalogue de confiance pré-approuvé. Aucun code JavaScript arbitraire généré par le LLM n’est jamais exécuté.
  2. MCP Apps (extension officielle MCP ui://) : Lorsqu’un outil MCP a besoin d’afficher un composant sur mesure très spécifique (un visualiseur 3D, un éditeur cartographique complexe) qui n’existe pas dans le catalogue natif du client, le serveur MCP renvoie une ressource ui:// exécutée dans une iframe HTML sandboxée communiquant en JSON-RPC bidirectionnel avec l’hôte.

4.2. Déconstruction institutionnelle n°4 : « AG-UI est le standard d’interface intégré à tous les frameworks »

1. L’affirmation simplifiée

« AG-UI est le protocole standard agent-utilisateur, gouverné comme MCP et A2A et nativement intégré à tous les grands frameworks d’agents (LangGraph, CrewAI, Microsoft, AWS, OpenAI, Anthropic). »

2. Ce qu’elle a de juste et ce qu’elle masque

• Qui a initié et gouverne AG-UI : AG-UI a été conçu et lancé par CopilotKit le 12 mai 2025 (sous l’impulsion d’Atai Barkai, Markus Ecker et Nathan Tarbert), à partir d’un partenariat initial avec LangGraph (LangChain) et CrewAI. Contrairement à MCP et A2A, AG-UI n’appartient pas à la Linux Foundation : le projet est publié sous licence MIT au sein de l’organisation GitHub ag-ui-protocol pilotée par CopilotKit, avec un groupe de travail public bi-hebdomadaire (AG-UI Working Group).
• Ce que masque l’expression « intégré aux frameworks » : L’examen direct de la matrice officielle d’intégrations dans le dépôt ag-ui-protocol/ag-ui montre que le mot « intégré » agrège en réalité quatre niveaux de prise en charge très différents :
  1. Prise en charge native 1st-party documentée et maintenue par l’éditeur cloud lui-même : C’est le cas de Microsoft Agent Framework (documenté officiellement sur learn.microsoft.com) et d’Amazon Bedrock AgentCore Runtime (documenté officiellement sur docs.aws.amazon.com).
  2. Co-développement officiel via middleware dédié : C’est le cas des partenaires historiques LangGraph, CrewAI, Mastra, Pydantic AI, Agno, LlamaIndex, ou encore Google ADK (dont l’intégration repose sur le paquet adk-middleware documenté sur docs.copilotkit.ai/adk).
  3. Adaptateurs communautaires ou maintenus dans le monorepo d’AG-UI : Par exemple, l’intégration Claude Agent SDK (integrations/claude-agent-sdk dans le dépôt ag-ui) ou Cloudflare Agents sont des adaptateurs hébergés et maintenus côté AG-UI/CopilotKit, et non dans les dépôts amont d’Anthropic ou de Cloudflare.
  4. Chantiers en cours (🛠️ In Progress) : Dans le tableau officiel du README.md d’AG-UI, des acteurs majeurs souvent cités sur les infographies comme OpenAI Agent SDK, AWS Bedrock Agents (hors AgentCore), Flowise (Issue #367) et Langflow (Issue #366) sont explicitement marqués 🛠️ In Progress.

3. Chronologie reconstituée et vérifiée sur sources primaires (AG-UI, MCP Apps et A2UI)

• Événement 1 : Lancement public du protocole AG-UI par CopilotKit :

  • Date de l’événement : 12 mai 2025 : Date de publication de la source : 12 mai 2025.
  • Fait précis et acteurs : Nathan Tarbert (CopilotKit) annonce le lancement d’AG-UI sous licence MIT, fruit d’un partenariat initial avec LangGraph et CrewAI, définissant une quinzaine de types d’événements standardisés pour le streaming temps réel entre agents backend et applications frontend.
  • Sources officielles :
    1. « Introducing AG-UI: The Protocol Where Agents Meet Users » (12 mai 2025, CopilotKit Blog) : https://www.copilotkit.ai/blog/introducing-ag-ui-the-protocol-where-agents-meet-users
    2. « AG-UI Protocol Repository & Integrations Matrix (README.md) » : https://github.com/ag-ui-protocol/ag-ui/blob/main/README.md

• Événement 2 : Annonce de MCP Apps (ui://) par l’écosystème MCP (Anthropic, OpenAI, MCP-UI, Goose) :

  • Date de l’événement : 21 novembre 2025 : Date de publication de la source : 21 novembre 2025.
  • Fait précis et acteurs : Les créateurs de MCP-UI (Ido Salomon, Liad Yosef), Sean Reece (Anthropic), Olivier Chappe et Nick Cooper (OpenAI), ainsi que les mainteneurs de Block/Goose annoncent MCP Apps (SEP-1865), standardisant l’affichage d’interfaces interactives déclarées via le schéma ui:// et rendues dans des iframes sandboxées au-dessus de MCP.
  • Source officielle : « MCP Apps: Extending servers with interactive user interfaces » (21 novembre 2025, MCP Official Blog) : https://blog.modelcontextprotocol.io/posts/2025-11-21-mcp-apps/

• Événement 3 : Lancement public de Google A2UI (Agent-to-User Interface) v0.8 :

  • Date de l’événement : 15 décembre 2025 : Date de publication de la source : 15 décembre 2025.
  • Fait précis et acteurs : imaswamy et James Wren (Google, avec des contributions de Opal, Flutter, Angular et Gemini Enterprise, ainsi que le soutien de CopilotKit / AG-UI) publient A2UI v0.8 sous licence Apache 2.0.
  • Nuance apportée : Dès son annonce initiale, Google précise qu’A2UI ne remplace pas AG-UI mais s’y imbrique : AG-UI fournit le tuyau de transport événementiel et la gestion d’état de session, tandis qu’A2UI définit le format JSON déclaratif des widgets générés à la volée.
  • Sources officielles :
    1. « Introducing A2UI: An open project for agent-driven interfaces » (15 décembre 2025, Google Developers Blog) : https://developers.googleblog.com/introducing-a2ui-an-open-project-for-agent-driven-interfaces/
    2. « AG-UI and A2UI: How They Work Together » (CopilotKit Documentation) : https://www.copilotkit.ai/ag-ui-and-a2ui

• Événement 4 : Sortie d’A2UI v0.9 et convergence officielle A2UI + MCP Apps :

  • Dates des événements et publications :
    • Sortie d’A2UI v0.9 (API createCatalog, validation de schémas sur mesure, support React complet) : 17 avril 2026 (https://a2ui.org/).
    • Annonce conjointe A2UI + MCP Apps : 17 juin 2026.
  • Fait précis et acteurs : Le 17 juin 2026, Google publie l’architecture de convergence entre A2UI (rendu natif déclaratif sans iframe) et MCP Apps (composants isolés en iframe), permettant par exemple d’encapsuler un flux A2UI à l’intérieur d’une MCP App ou d’embarquer une MCP App dans une vue A2UI.
  • Sources officielles :
    1. « A2UI Official Specification & v0.9 Release Notes (April 17, 2026) » : https://a2ui.org/
    2. « A2UI + MCP Apps: Combining the best of declarative and custom agentic UIs » (17 juin 2026, Google Developers Blog) : https://developers.googleblog.com/a2ui-and-mcp-apps/

4. Pourquoi cette distinction compte

• Motivations explicitement annoncées par les acteurs : CopilotKit et Google expliquent qu’un développeur frontend a besoin à la fois d’un protocole de transport temps réel pour l’état de session de l’agent (AG-UI) et d’un format déclaratif sûr pour que le LLM compose des écrans sans injecter de code exécutable (A2UI).
• Analyse architecturale et institutionnelle : Lorsqu’une équipe choisit d’adopter AG-UI en production, elle doit vérifier dans laquelle des quatre catégories tombe son framework backend : utiliser AG-UI avec Microsoft Agent Framework, Amazon Bedrock AgentCore ou LangGraph s’appuie sur des intégrations matures et documentées de bout en bout ; en revanche, supposer qu’OpenAI Agent SDK ou Flowise disposent du même niveau de prise en charge native upstream expose à des surprises, puisque ces connecteurs figurent encore comme chantiers ouverts (🛠️ In Progress) dans le dépôt d’AG-UI.

5. Formulation exacte et réutilisable

Formulation exacte : « Initié par CopilotKit le 12 mai 2025 sous licence MIT (hors Linux Foundation), AG-UI standardise le flux d’événements temps réel (SSE/état partagé) entre un agent et son interface. Sa mention “intégré aux frameworks” recouvre toutefois des maturités distinctes : support 1st-party officiel chez Microsoft Agent Framework et AWS Bedrock AgentCore, middlewares co-développés avec LangGraph/CrewAI/Google ADK, adaptateurs maintenus dans le monorepo AG-UI (Claude Agent SDK), et chantiers encore en cours (OpenAI Agent SDK, Flowise). Par ailleurs, AG-UI ne concurrence pas A2UI de Google (15 décembre 2025) ni MCP Apps (21 novembre 2025) : AG-UI transporte le flux de session, A2UI décrit les composants natifs en JSON déclaratif, et MCP Apps isole les vues HTML tierces en iframe. »

5. Tableau récapitulatif de vérification : Infographie simplifiée vs Réalité historique et technique

6. Index complet des sources primaires vérifiées (URLs directes)

Pour permettre une vérification immédiate de chaque date, charte et numéro de version cités dans cet article, voici la liste intégrale des sources primaires officielles consultées :

1. A2A : Annonce initiale (9 avril 2025) :
   • « Announcing the Agent2Agent Protocol (A2A) » : Google Developers Blog : https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
2. A2A : Annonces contemporaines du transfert à la Linux Foundation (23 juin 2025) :
   • « Linux Foundation Launches the Agent2Agent Protocol Project to Enable Secure, Intelligent Communication Between AI Agents » : Linux Foundation Press : https://www.linuxfoundation.org/press/linux-foundation-launches-the-agent2agent-protocol-project-to-enable-secure-intelligent-communication-between-ai-agents
   • « Google Cloud donates A2A to Linux Foundation » : Google Developers Blog : https://developers.googleblog.com/en/google-cloud-donates-a2a-to-linux-foundation/
3. A2A : Charte de gouvernance et liste des 9 sièges du TSC (GOVERNANCE.md) :
   • « Agent2Agent Project Governance » : GitHub a2aproject/A2A : https://github.com/a2aproject/A2A/blob/main/GOVERNANCE.md
4. A2A : Releases techniques v1.0.0 (12 mars 2026) et v1.0.1 (26 mai 2026) & Rétrospective (16 avril 2026) :
   • « A2A GitHub Releases » : https://github.com/a2aproject/A2A/releases
   • « A year of open collaboration: Celebrating the anniversary of A2A » : Google Open Source Blog : https://opensource.googleblog.com/2026/04/a-year-of-open-collaboration-celebrating-the-anniversary-of-a2a.html
5. ACP (IBM Research / BeeAI) : Fusion officielle dans A2A (25 août 2025, après lancement en mars 2025) :
   • « ACP Joins Forces with A2A Under the Linux Foundation · i-am-bee · Discussion #5 » : https://github.com/orgs/i-am-bee/discussions/5
   • « Agent Communication Protocol (ACP) Repository » : https://github.com/i-am-bee/acp
6. MCP : Annonce initiale (25 novembre 2024, spec 2024-11-05) et Changelogs officiels (2025-03-26, 2025-06-18, 2025-11-25) :
   • « Introducing the Model Context Protocol » : Anthropic News : https://www.anthropic.com/news/model-context-protocol
   • « Key Changes - Version 2025-03-26 » : https://modelcontextprotocol.io/specification/2025-03-26/changelog
   • « Key Changes - Version 2025-06-18 » : https://modelcontextprotocol.io/specification/2025-06-18/changelog
   • « Key Changes - Version 2025-11-25 » : https://modelcontextprotocol.io/specification/2025-11-25/changelog
7. MCP & AAIF : Création de l’Agentic AI Foundation (9 décembre 2025) et Charte de gouvernance BDFL :
   • « Donating the Model Context Protocol and establishing the Agentic AI Foundation » : Anthropic News : https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation
   • « Linux Foundation Announces the Formation of the Agentic AI Foundation (AAIF) » : Linux Foundation Press : https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation
   • « Governance and Dual-Process Stewardship : Model Context Protocol » : https://modelcontextprotocol.io/community/governance
8. AG-UI, MCP Apps et A2UI : Lancements et intégrations (12 mai 2025, 21 novembre 2025, 15 décembre 2025, 17 avril 2026, 17 juin 2026) :
   • « Introducing AG-UI: The Protocol Where Agents Meet Users » (12 mai 2025) : https://www.copilotkit.ai/blog/introducing-ag-ui-the-protocol-where-agents-meet-users
   • « AG-UI Repository & Framework Integration Status » : https://github.com/ag-ui-protocol/ag-ui/blob/main/README.md
   • « Microsoft Agent Framework AG-UI Integration » : https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/ui/ag-ui/
   • « Amazon Bedrock AgentCore Runtime AG-UI Protocol » : https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-agui.html
   • « MCP Apps: Extending servers with interactive user interfaces » (21 novembre 2025) : https://blog.modelcontextprotocol.io/posts/2025-11-21-mcp-apps/
   • « Introducing A2UI: An open project for agent-driven interfaces » (15 décembre 2025) : https://developers.googleblog.com/introducing-a2ui-an-open-project-for-agent-driven-interfaces/
   • « A2UI v0.9 Official Site (17 avril 2026) » : https://a2ui.org/
   • « A2UI + MCP Apps: Combining the best of declarative and custom agentic UIs » (17 juin 2026) : https://developers.googleblog.com/a2ui-and-mcp-apps/