Kling Digital
fr
Contact
2026-11-19
8 MIN LECTURE
Guide En Vedette

AG-UI : le protocole standard reliant les agents IA aux interfaces

AG-UI (Agent-User Interaction Protocol) est un protocole open source sous licence MIT et orienté événements qui standardise la liaison entre agents IA et interfaces web, mobiles ou terminal. Il unifie streaming incrémental, appels d'outils en cours de réponse, deltas RFC 6902 et pauses d'approbation humaine.

AG-UI : le protocole standard reliant les agents IA aux interfaces

Une fois qu'un agent IA fonctionne de manière fiable côté serveur, son raccordement à une application web, mobile ou terminal se transforme presque toujours en bricolage fragile : le texte circule selon un schéma maison, les appels d'outils au milieu d'une réponse adoptent un autre format JSON, l'état partagé se désynchronise et les validations humaines restent suspendues sur des connexions prêtes à rompre.

AG-UI (Agent-User Interaction Protocol), hébergé sous ag-ui-protocol/ag-ui avec une licence MIT, définit un protocole ouvert, léger et événementiel pour connecter les agents IA aux interfaces utilisateur. Il rassemble dans une même norme le streaming progressif des réponses, les appels d'outils en cours de génération, la synchronisation d'état partagé et les pauses d'approbation humaine sur web, mobile et terminal.

Important
  • Flux d'événements typés unique : Des familles normalisées (RUN_STARTED, TEXT_MESSAGE_CONTENT, TOOL_CALL_START, STATE_DELTA) découplent l'interface du framework d'agent choisi côté backend.
  • Interruptions propres pour la validation humaine (HITL) : Plutôt que de bloquer une socket pendant l'attente d'un clic, l'exécution se clôt proprement sur RUN_FINISHED avec un état interrupt, puis reprend via un payload resume.
  • Position complémentaire à MCP et A2A : Alors que MCP relie l'agent aux outils et A2A relie les agents entre eux, AG-UI normalise la frontière agent <-> interface utilisateur.

Pour les organisations qui conçoivent des solutions d'intelligence artificielle et des projets multiplateformes de développement logiciel, coupler directement le frontend à un seul moteur d'agent (LangChain, CrewAI, Google ADK ou Microsoft Agent Framework) crée une dette de migration lourde. À chaque évolution du backend, tous les parseurs React, iOS, Android et CLI doivent être refaits. AG-UI supprime ce couplage et s'impose comme candidat de référence pour la communication agent-interface.

Pourquoi les API REST classiques échouent face aux interfaces d'agents

Une API REST classique repose sur un échange linéaire : une requête client entraîne une réponse complète. Un agent IA moderne rompt ce modèle sur quatre axes :

  1. Texte et outils entrelacés : L'agent diffuse des fragments de réponse, interrompt sa rédaction pour déclencher un outil serveur ou client, puis reprend le fil avec le résultat.
  2. État applicatif partagé : Listes de tâches, formulaires et statuts de sous-agents évoluent en continu et doivent se synchroniser sans recharger l'état complet.
  3. Validation humaine gouvernée : Les actions sensibles — suppression en base, envoi d'e-mails clients ou validation financière — doivent marquer un arrêt explicite avant exécution.
  4. Échanges multimodaux : Fichiers typés, images et contexte d'écran circulent désormais dans les deux sens aux côtés du texte.

Au sein des tendances de l'écosystème open source des agents IA de novembre 2026, chaque framework imposait jusque-là son dialecte de streaming. Porté aux côtés de CopilotKit sous gouvernance ouverte ag-ui-protocol, AG-UI répond à cette fragmentation par un contrat unifié.

AG-UI face à MCP et A2A dans la pile des protocoles d'agents

Les architectures d'agents modernes s'appuient sur trois protocoles ouverts complémentaires plutôt qu'un standard unique monolithique :

Protocole / ApprocheFrontière normaliséeQuestion clé résolueTransport et modèle de donnéesRôle principal
AG-UIAgent <-> Interface utilisateur« Comment mon agent dialogue-t-il avec le web, le mobile ou le terminal ? »SSE ou WebSocket agnostique + événements typés + RFC 6902 JSON PatchStreaming UI, outils en direct, état partagé et pauses HITL
MCPAgent <-> Outils et données« Comment l'agent découvre-t-il et exécute-t-il outils et bases de données ? »JSON-RPC (stdio / Streamable HTTP)Connecteurs de données, ressources locales et outils comme REA MCP
A2AAgent <-> Agent« Comment des agents distribués se délèguent-ils des tâches ? »Contrats de tâches HTTP / JSON-RPC (Google / Linux Foundation)Orchestration multi-agents entre domaines
REST / SSE sur mesureUn backend <-> Une UI« Comment câbler vite un prototype isolé ? »Trames JSON propriétaires non standardiséesPetits prototypes ; forte dette sur plusieurs clients

Dans une architecture complète, votre agent interroge ses outils et sa mémoire via MCP (par exemple avec la mémoire persistante claude-mem), délègue des sous-tâches spécialisées via A2A et pilote l'ensemble de l'interface utilisateur via AG-UI.

Familles d'événements et indépendance vis-à-vis du transport

AG-UI est conçu pour rester indépendant du transport : il fonctionne sur Server-Sent Events (SSE) pour des flux légers du serveur vers l'interface, ou sur WebSockets lorsqu'une communication bidirectionnelle temps réel est requise (annulation immédiate, contexte utilisateur continu, outils exécutés côté client).

La spécification organise la session en quatre familles d'événements fortement typés :

1. Cycle de vie des exécutions et étapes (Runs & Steps)

  • RUN_STARTED : Signale le démarrage d'une exécution avec ses métadonnées threadId et runId.
  • STEP_STARTED et STEP_FINISHED : Exposent chaque étape interne du graphe d'agent pour afficher une progression transparente.
  • RUN_FINISHED et RUN_ERROR : Indiquent la fin nominale, une pause d'approbation structurée (interrupt) ou une erreur d'exécution.

2. Flux de messages texte (Text Messages)

  • TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT, TEXT_MESSAGE_END et TEXT_MESSAGE_CHUNK : Transmettent les deltas textuels associés à un identifiant de message explicite, permettant d'afficher plusieurs flux simultanés sans collision.

3. Appels d'outils en cours de réponse (Tool Calls)

  • TOOL_CALL_START, TOOL_CALL_ARGS, TOOL_CALL_END, TOOL_CALL_RESULT et TOOL_CALL_CHUNK : Diffusent l'intention d'appel et les arguments JSON au fil de leur génération afin que l'interface affiche immédiatement une carte de suivi ou un composant génératif.

4. Synchronisation d'état partagé (State Management)

  • STATE_SNAPSHOT : Transmet l'état complet à la connexion initiale ou après une reconnexion réseau.
  • STATE_DELTA : Envoie uniquement les modifications incrémentales au format RFC 6902 JSON Patch, préservant la bande passante et évitant tout rafraîchissement brutal des tableaux et formulaires.
Astuce

Des frameworks majeurs tels que LangChain, CrewAI, Microsoft Agent Framework, Google ADK, LlamaIndex et Pydantic AI proposent des adaptateurs AG-UI natifs ou intégrés. S'appuyer sur AG-UI côté client permet de faire évoluer le moteur serveur sans casser le frontend.

Pauses d'approbation humaine (HITL) et reprise fiable

Maintenir un flux HTTP ouvert en attendant qu'un opérateur clique sur un bouton échoue régulièrement à cause des timeouts de proxy ou de la mise en veille mobile. AG-UI résout le Human-in-the-Loop (HITL) via des interruptions terminales : l'exécution s'achève proprement par un événement RUN_FINISHED portant un résultat interrupt et ses interruptId.

Lorsque l'utilisateur valide ou refuse l'opération, le client relance une exécution via HttpAgent de @ag-ui/client en transmettant le tableau resume :

import { HttpAgent } from "@ag-ui/client";
const agent = new HttpAgent({
  url: "https://api.example.com/agent",
  headers: {
    Authorization: `Bearer ${process.env.AGUI_TOKEN}`,
  },
  threadId: "thread-ops-4821",
});
agent.messages.push({
  id: "msg-user-1",
  role: "user",
  content: "Purger les brouillons temporaires de factures archivés depuis 90 jours.",
});
async function executeWithApproval() {
  // 1. L'exécution initiale se termine proprement sur une interruption HITL
  await agent.runAgent();
  // Identifiant récupéré depuis l'événement RUN_FINISHED et décision utilisateur :
  const pendingInterruptId = "intr-clean-drafts-01";
  const approvedByReviewer = true;
  // 2. Reprise propre sur le même threadId avec le payload resume
  const resumed = await agent.runAgent({
    resume: [
      {
        interruptId: pendingInterruptId,
        status: approvedByReviewer ? "resolved" : "cancelled",
        payload: {
          approved: approvedByReviewer,
          comment: approvedByReviewer
            ? "Approuvé depuis le tableau de bord opérations."
            : "Rejeté selon la politique de rétention.",
        },
      },
    ],
  });
  return resumed;
}

Que le valideur réponde en trois secondes ou en trois heures, aucune connexion serveur ne reste bloquée ; l'agent reprend proprement sur le même threadId à partir de son point de contrôle.

Écosystème SDK pour le web, le mobile et le terminal

La séparation stricte entre transport d'événements et moteur de rendu permet d'alimenter tous les terminaux depuis un même endpoint :

  • Web (support officiel) : Paquets TypeScript (@ag-ui/core, @ag-ui/client) et CopilotKit pour React, Angular et Vue avec gestion native des patchs d'état et des instantanés.
  • Mobile et multiplateforme : SDK Kotlin Multiplatform (Android, iOS, JVM), bibliothèques natives Swift (async/await et Codable), support React Native ainsi que paquets communautaires Flutter gérant le streaming SSE et les formulaires HITL.
  • Terminal et CLI : Clients en ligne de commande en Node.js/TypeScript, Python ou .NET consommant directement le flux d'événements pour des consoles interactives et moniteurs d'agents.
  • Langages de spécification 1.0 : Schémas officiels en TypeScript, Python et .NET, complétés par des SDK communautaires en Go, Rust, Java, Dart/Flutter, Ruby et C++.
Avertissement

Sécurité et contrôle d'accès : AG-UI normalise le transport d'événements, pas l'autorisation. Ne faites jamais confiance aveuglément à un approved: true envoyé par le client dans resume : revérifiez toujours côté serveur la session authentifiée, les droits RBAC et la concordance entre interruptId et threadId. Pour maîtriser aussi les coûts de tokens sur des agents à fort débit, consultez notre guide sur la compression de tokens Caveman.

Quand adopter AG-UI dans votre architecture produit ?

Un simple endpoint HTTP suffit pour générer un paragraphe statique. En revanche, AG-UI devient rapidement rentable dès que deux de ces besoins se présentent :

  1. Un même agent doit desservir web, mobile et terminal sans dupliquer les couches de streaming.
  2. Les utilisateurs doivent suivre en direct les appels d'outils, l'état partagé et les étapes de validation humaine.
  3. Vous souhaitez conserver la liberté de faire évoluer votre framework d'agent backend sans réécrire vos interfaces.

Pour estimer le budget de conception d'une architecture agéntique multiplateforme, utilisez notre calculateur de coût ou contactez nos ingénieurs via la page contact de Kling Digital.

Foire Aux Questions

Questions fréquemment posées concernant ce guide.

Retour aux Actualités
Partager

Commentaires (0)

Partagez vos réflexions et vos idées avec la communauté.

Aucun commentaire pour le moment. Soyez le premier à commenter !

Laissez un commentaire

Votre commentaire sera publié après validation par un administrateur.

Autorité Thématique & Centre de Ressources

Benchmarks Architecturaux, Guides Piliers & Outils Digitaux

Matrices de référence, guides d'ingénierie B2B et outils interactifs pour orienter vos décisions techniques.

Benchmark Technique

Comparatif Next.js vs WordPress

Chargement sous la seconde, zéro risque lié aux extensions et comparatif du coût total sur 3 ans.

Lire l'Analyse Comparative Complète
Benchmark Architectural

Comparaison Architecturale Framer vs Next.js

Outils de conception visuelle versus développement logiciel d'entreprise complet.

Lire l'Analyse Comparative Complète