Als KI-Agenten leistungsfähig genug werden, um echte Workflows zu bewältigen, ist eine neue Infrastruktur-Herausforderung entstanden: Wie kommunizieren Menschen und Agenten während der Ausführung – nicht nur am Anfang und Ende, sondern durchgehend?
Das AG-UI-Protokoll ist eine offene Spezifikation, die genau dieses Problem löst. Es definiert einen Standard dafür, wie KI-Agenten Ereignisse streamen, Eingaben anfordern und ihren Zustand für Frontend-Anwendungen und menschliche Operatoren in Echtzeit bereitstellen. Wenn MCP (Model Context Protocol) standardisiert hat, wie Agenten auf Tools zugreifen, standardisiert AG-UI, wie Agenten mit Benutzern kommunizieren.
Dieser Leitfaden erklärt, was AG-UI ist, warum es wichtig ist, wie es funktioniert und wie Sie es in Ihrem Agenten-Stack einsetzen können.
Das Problem, das AG-UI löst
Vor AG-UI musste jedes Team, das eine nutzerorientierte KI-Agenten-Anwendung entwickelte, sein eigenes Kommunikationsprotokoll erfinden. Wie teilt der Agent dem Frontend mit, dass er nachdenkt? Wie fordert er eine menschliche Entscheidung an? Wie sendet der Benutzer eine Korrektur mitten in einer Aufgabe? Wie wird der Fortschritt angezeigt?
Die Antworten waren für jedes Team unterschiedlich – oft ad hoc, schlecht dokumentiert und schwer wiederverwendbar. Dies schuf ein fragmentiertes Ökosystem, in dem:
- Agenten-Frameworks keine Frontend-Komponenten teilen konnten
- Entwickler die Streaming-UI-Infrastruktur für jedes Projekt von Grund auf neu aufbauen mussten
- Benutzer inkonsistente Erfahrungen mit agenten-basierten Produkten machten
- Das Debugging von Agenten-Verhalten individuelle Protokollierung in jeder Implementierung erforderte
AG-UI etabliert ein gemeinsames Vokabular und eine Ereignisstruktur, sodass jedes Agenten-Framework Ereignisse erzeugen kann, die jedes AG-UI-kompatible Frontend darstellen kann – ohne benutzerdefinierten Integrationscode.
Was ist AG-UI?
AG-UI ist ein offenes, streaming-basiertes Ereignisprotokoll, das das Format und die Semantik der Nachrichten definiert, die zwischen KI-Agenten und nutzerorientierten Schnittstellen ausgetauscht werden.
Es ist:
- Transport-agnostisch: funktioniert über HTTP (Server-Sent Events), WebSockets oder jeden anderen Streaming-Transport
- Framework-agnostisch: kann in jeder Sprache oder jedem Agenten-Framework implementiert werden
- Bidirektional: Agenten senden Ereignisse an das Frontend; Benutzer senden Nachrichten und Unterbrechungen an den Agenten
- Zustandsbehaftet: Das Protokoll enthält Zustands-Snapshots, damit Frontends den vollständigen Agenten-Kontext jederzeit rekonstruieren können
Es ist nicht:
- Ein Tool-Protokoll (das ist MCPs Aufgabe)
- Ein Agenten-Framework selbst
- Eine UI-Komponentenbibliothek (obwohl Referenzimplementierungen existieren)
AG-UI vs. MCP: Den Unterschied verstehen
Eine häufige Verwirrungsquelle ist, wie AG-UI sich zu Anthropics Model Context Protocol (MCP) verhält.
| Dimension | MCP | AG-UI |
|---|---|---|
| Zweck | Agent ↔ Tool-Kommunikation | Agent ↔ Mensch/Frontend-Kommunikation |
| Richtung | Agent ruft Tools auf, empfängt Ergebnisse | Agent streamt Ereignisse; Mensch sendet Nachrichten |
| Zielgruppe | Tool-/Server-Entwickler | Frontend- und Agenten-Framework-Entwickler |
| Fokus | Welche Fähigkeiten der Agent nutzen kann | Wie der Agent seinen Zustand und Fortschritt kommuniziert |
| Beziehung | Verwaltet die „Tool"-Seite des Agenten | Verwaltet die „Benutzeroberflächen"-Seite |
Sie ergänzen sich gegenseitig. Ein Agent, der im Produktionsbetrieb läuft, verwendet typischerweise MCP für den Zugriff auf Tools (Websuche, Bildgenerierung, Code-Ausführung) und AG-UI, um seinen Fortschritt zu kommunizieren und menschliche Eingaben anzufordern.
Kernkonzepte in AG-UI
Ereignistypen
AG-UI definiert eine Standardmenge von Ereignistypen, die Agenten ausgeben:
Lebenszyklus-Ereignisse:
RUN_STARTED/RUN_FINISHED– der Agent hat die Ausführung begonnen oder abgeschlossenSTEP_STARTED/STEP_FINISHED– ein diskreter Schritt im Workflow hat begonnen oder geendetRUN_ERROR– der Agent ist auf einen nicht behebbaren Fehler gestoßen
Nachrichten-Ereignisse:
TEXT_MESSAGE_START/TEXT_MESSAGE_CONTENT/TEXT_MESSAGE_END– gestreamte Textausgabe des AgentenTOOL_CALL_START/TOOL_CALL_ARGS/TOOL_CALL_END– der Agent ruft ein Tool auf
Zustands-Ereignisse:
STATE_SNAPSHOT– ein vollständiger Snapshot des aktuellen Agenten-ZustandsSTATE_DELTA– ein inkrementelles Update des ZustandsMESSAGES_SNAPSHOT– der vollständige Gesprächsverlauf zu einem bestimmten Zeitpunkt
Benutzerdefinierte Ereignisse:
CUSTOM– für anwendungsspezifische Ereignisse, die nicht durch den Standardsatz abgedeckt sind
Die Mensch-Runde
AG-UI standardisiert auch, wie Menschen mit laufenden Agenten interagieren. Das Frontend sendet einen AgentInput, um den Agenten zu unterbrechen, umzuleiten oder ihm während der Ausführung Informationen bereitzustellen. Dies unterscheidet sich von einem neuen Gesprächszug – der Agent läuft, und der Mensch beeinflusst seine aktuelle Aufgabe.
Thread-basierte Architektur
AG-UI organisiert Agenten-Läufe in Threads – persistente Gesprächskontexte, die den Zustand über mehrere Läufe hinweg aufrechterhalten. Ein Thread in AG-UI entspricht in etwa einer Sitzung oder einem Gespräch in anderen Frameworks, bietet aber explizite Protokollunterstützung für das Fortsetzen, Verzweigen und Wiederholen.
Wie AG-UI funktioniert: Ein typischer Ablauf
1. Benutzer sendet eine Aufgabe über das Frontend
2. Frontend sendet InitialRun-Anfrage mit RunAgentInput an das Agenten-Backend
3. Agent beginnt die Ausführung und gibt RUN_STARTED-Ereignis aus
4. Agent gibt STEP_STARTED für jeden Planungsschritt aus
5. Agent ruft ein Tool auf → gibt TOOL_CALL_START, TOOL_CALL_ARGS, TOOL_CALL_END aus
6. Agent generiert Text → gibt TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT (streaming), TEXT_MESSAGE_END aus
7. Agent gibt STATE_DELTA aus, um den Frontend-Zustand in Echtzeit zu aktualisieren
8. Benutzer entscheidet, den Agenten umzuleiten → sendet AgentInput mit Korrektur
9. Agent verarbeitet die Korrektur und macht weiter
10. Agent gibt RUN_FINISHED aus
Das Frontend empfängt diese Ereignisse als Stream und rendert sie progressiv – zeigt Tool-Aufrufe, während sie stattfinden, streamt Text in Echtzeit und aktualisiert eine Fortschrittsanzeige basierend auf Schritt-Ereignissen.
AG-UI implementieren
Framework-Unterstützung
AG-UI gewinnt Unterstützung in wichtigen Agenten-Frameworks:
- LangGraph: AG-UI-Ereignisse können aus Graph-Knoten mithilfe des AG-UI Python SDK ausgegeben werden
- AG-UI CopilotKit-Integration: CopilotKit (ein React-Frontend-Framework für KI) beinhaltet native AG-UI-Unterstützung
- Benutzerdefinierte Implementierungen: Die AG-UI-Spezifikation ist offen; jedes Framework kann sie mit den Ereignistyp-Definitionen implementieren
Schnellstart (Python)
from ag_ui.core import (
RunAgentInput, EventType,
RunStartedEvent, TextMessageStartEvent,
TextMessageContentEvent, TextMessageEndEvent,
RunFinishedEvent,
)
import uuid
async def run_agent(input: RunAgentInput):
run_id = str(uuid.uuid4())
yield RunStartedEvent(
type=EventType.RUN_STARTED,
thread_id=input.thread_id,
run_id=run_id,
)
msg_id = str(uuid.uuid4())
yield TextMessageStartEvent(type=EventType.TEXT_MESSAGE_START, message_id=msg_id, role="assistant")
for chunk in agent.stream(input.messages):
yield TextMessageContentEvent(
type=EventType.TEXT_MESSAGE_CONTENT,
message_id=msg_id,
delta=chunk
)
yield TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=msg_id)
yield RunFinishedEvent(type=EventType.RUN_FINISHED, thread_id=input.thread_id, run_id=run_id)
Verbindung mit AnyCap
Wenn Ihr AG-UI-betriebener Agent reale Fähigkeiten benötigt – Websuche, Bildgenerierung, Dateispeicherung – integriert sich AnyCap als Tool-Schicht unterhalb der Orchestrierung. Der Agent ruft AnyCap-Tools während seiner Ausführungsschleife auf und gibt die entsprechenden TOOL_CALL_*-Ereignisse aus, damit das Frontend zeigt, was passiert:
Benutzer: "Recherchiere die 5 wichtigsten KI-Frameworks und erstelle ein Zusammenfassungsbild"
Agent gibt aus: TOOL_CALL_START (tool: "anycap_search", args: {...})
Agent gibt aus: TOOL_CALL_END (result: Suchergebnisse)
Agent gibt aus: TOOL_CALL_START (tool: "anycap_image_generate", args: {...})
Agent gibt aus: TOOL_CALL_END (result: Bild-URL)
Agent gibt aus: TEXT_MESSAGE (streaming Zusammenfassung mit eingebettetem Bild)
Diese vollständige Transparenz – bereitgestellt durch AG-UI-Ereignisse – ist das, was eine vertrauenswürdige Mensch-Agent-Schnittstelle von einer Black Box unterscheidet.
Warum AG-UI für Produktions-Agenten-Anwendungen wichtig ist
Wenn Sie agenten-basierte Produkte entwickeln, bietet AG-UI:
Wiederverwendbarkeit von Komponenten. Frontend-Komponenten, die nach der AG-UI-Spezifikation entwickelt wurden, funktionieren mit jedem konformen Backend. Entwickeln Sie einmal eine Streaming-Chat-UI; verwenden Sie sie mit LangGraph, CrewAI und AutoGen ohne Änderungen.
Konsistente Benutzererfahrung. Benutzer sehen dieselben Interaktionsmuster in verschiedenen Agenten-Workflows, da die Ereignistypen standardisiert sind.
Debugging. AG-UIs Zustands-Snapshots und Ereignis-Stream bieten eine vollständige Aufzeichnung der Agenten-Ausführung. Das Wiedergeben eines Ereignis-Streams zeigt genau, was der Agent bei jedem Schritt gesehen und getan hat.
Menschliche Aufsicht. Der AgentInput-Mechanismus für menschliche Eingriffe während laufender Aufgaben ist in das Protokoll integriert – nicht nachträglich hinzugefügt.
Fazit
AG-UI füllt eine echte Lücke im agentenbasierten KI-Infrastruktur-Stack. Da Agenten leistungsfähiger und nutzerorientierter werden, wird das Protokoll für die Kommunikation ihres Zustands und den Empfang menschlicher Eingaben genauso wichtig wie die Tools, auf die sie zugreifen können.
Für Entwickler, die 2026 agenten-basierte Produkte entwickeln, bedeutet die frühzeitige Einführung von AG-UI, auf einem Fundament aufzubauen, auf das das Ökosystem zusteuert – anstatt eine maßgeschneiderte Kommunikationsschicht zu warten, die mit dem Wachstum Ihres Produkts zur Belastung wird.
Weiterführende Literatur: