AG-UI-Protokoll erklärt: Der neue Standard für Mensch-Agenten-Schnittstellen

AG-UI-Protokoll erklärt: Der neue Standard für Mensch-Agenten-Schnittstellen

Da KI-Agenten in der Lage sind, echte Arbeitsabläufe zu übernehmen, entsteht eine neue Infrastrukturherausforderung: Wie kommunizieren Mensch und Agent 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 an Frontend-Anwendungen und menschliche Operatoren in Echtzeit übermitteln. Wenn MCP (Model Context Protocol) standardisiert hat, wie Agenten auf Werkzeuge 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 benutzerorientierte 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 schickt der Benutzer mitten in einer Aufgabe eine Korrektur? Wie wird der Fortschritt angezeigt?

Die Antworten waren je nach Team unterschiedlich – oft ad hoc, schlecht dokumentiert und schwer wiederverwendbar. Dies führte zu einem fragmentierten Ökosystem, in dem:

• Agenten-Frameworks keine Frontend-Komponenten teilen konnten
• Entwickler für jedes Projekt von Grund auf neue Streaming-UI-Infrastruktur aufbauen mussten
• Benutzer inkonsistente Erfahrungen bei verschiedenen agentengestützten Produkten hatten
• Das Debugging von Agentenverhalten benutzerdefiniertes Logging 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 rendern kann – ohne benutzerdefinierten Integrationscode.

Was ist AG-UI?

AG-UI ist ein offenes Streaming-Ereignisprotokoll, das das Format und die Semantik der Nachrichten definiert, die zwischen KI-Agenten und benutzerorientierter Oberfläche ausgetauscht werden.

Es ist:

• Transportunabhängig: funktioniert über HTTP (Server-Sent Events), WebSockets oder jeden anderen Streaming-Transport
• Framework-unabhängig: 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 Agentenkontext jederzeit rekonstruieren können

Es ist nicht:

• Ein Tool-Protokoll (das ist Aufgabe von MCP)
• Ein Agenten-Framework selbst
• Eine UI-Komponentenbibliothek (obwohl Referenzimplementierungen existieren)

AG-UI vs. MCP: Den Unterschied verstehen

Eine häufige Quelle der Verwirrung ist, wie AG-UI mit Anthropics Model Context Protocol (MCP) zusammenhängt.

Sie ergänzen sich gegenseitig. Ein in der Produktion laufender Agent nutzt typischerweise MCP für den Zugriff auf Werkzeuge (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 einen Standardsatz von Ereignistypen, die Agenten ausgeben:

Lifecycle-Ereignisse:

• RUN_STARTED / RUN_FINISHED — Der Agent hat die Ausführung begonnen oder abgeschlossen
• STEP_STARTED / STEP_FINISHED — Ein diskreter Schritt im Workflow hat begonnen oder ist beendet
• RUN_ERROR — Der Agent ist auf einen nicht behebbaren Fehler gestoßen

Nachrichtenereignisse:

• TEXT_MESSAGE_START / TEXT_MESSAGE_CONTENT / TEXT_MESSAGE_END — Streaming-Textausgabe des Agenten
• TOOL_CALL_START / TOOL_CALL_ARGS / TOOL_CALL_END — Der Agent ruft ein Werkzeug auf

Zustandsereignisse:

• STATE_SNAPSHOT — Ein vollständiger Snapshot des aktuellen Agentenzustands
• STATE_DELTA — Eine inkrementelle Aktualisierung des Zustands
• MESSAGES_SNAPSHOT — Die vollständige Konversationshistorie zu einem bestimmten Zeitpunkt

Benutzerdefinierte Ereignisse:

• CUSTOM — Für anwendungsspezifische Ereignisse, die nicht vom Standardsatz abgedeckt werden

Der menschliche Zug

AG-UI standardisiert auch, wie Menschen mit laufenden Agenten interagieren. Das Frontend sendet einen AgentInput, um den Agenten während der Ausführung zu unterbrechen, umzuleiten oder zu informieren. Dies unterscheidet sich von einem neuen Gesprächsschritt – der Agent läuft, und der Mensch beeinflusst seine aktuelle Aufgabe.

Thread-basierte Architektur

AG-UI organisiert Agenten-Ausführungen in Threads – persistente Konversationskontexte, die den Zustand über mehrere Ausführungen hinweg aufrechterhalten. Ein Thread in AG-UI entspricht in etwa einer Sitzung oder Konversation in anderen Frameworks, jedoch mit expliziter 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 Werkzeug 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 integriert die Korrektur und fährt fort
10. Agent gibt RUN_FINISHED aus

Das Frontend empfängt diese Ereignisse als Stream und rendert sie progressiv – zeigt Werkzeugaufrufe in Echtzeit, streamt Text live und aktualisiert einen Fortschrittsindikator basierend auf Schritt-Ereignissen.

AG-UI implementieren

Framework-Unterstützung

AG-UI gewinnt Unterstützung in führenden Agenten-Frameworks:

• LangGraph: AG-UI-Ereignisse können von Graph-Knoten mit dem AG-UI Python SDK ausgegeben werden
• AG-UI CopilotKit-Integration: CopilotKit (ein React-Frontend-Framework für KI) bietet native AG-UI-Unterstützung
• Benutzerdefinierte Implementierungen: Die AG-UI-Spezifikation ist offen; jedes Framework kann sie mit den Ereignistypendefinitionen 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-gestützter Agent reale Fähigkeiten benötigt – Websuche, Bildgenerierung, Dateispeicher – integriert sich AnyCap als Werkzeugschicht unterhalb der Orchestrierung. Der Agent ruft AnyCap-Werkzeuge während seiner Ausführungsschleife auf und gibt die entsprechenden TOOL_CALL_*-Ereignisse aus, damit das Frontend sieht, was gerade passiert:

Benutzer: "Recherchiere die Top 5 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 – sichtbar durch AG-UI-Ereignisse – ist das, was eine vertrauenswürdige Mensch-Agenten-Schnittstelle von einer Black Box unterscheidet.

Warum AG-UI für produktive Agenten-Anwendungen wichtig ist

Wenn Sie agentengestützte Produkte entwickeln, bietet AG-UI:

Wiederverwendbarkeit von Komponenten. Frontend-Komponenten, die nach der AG-UI-Spezifikation erstellt wurden, funktionieren mit jedem konformen Backend. Erstellen Sie einmalig eine Streaming-Chat-Oberfläche; nutzen 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 geben Ihnen eine vollständige Aufzeichnung der Agentenausführung. Das Wiederholen eines Ereignis-Streams zeigt genau, was der Agent bei jedem Schritt gesehen und getan hat.

Menschliche Aufsicht. Der AgentInput-Mechanismus für menschliche Interventionen mitten in einer Aufgabe ist in das Protokoll eingebaut – nicht als nachträglicher Gedanke angehängt.

Fazit

AG-UI füllt eine echte Lücke im agentenbasierten KI-Infrastruktur-Stack. Da Agenten leistungsfähiger und benutzerorientierter werden, wird das Protokoll für die Kommunikation ihres Zustands und die Entgegennahme menschlicher Eingaben genauso wichtig wie die Werkzeuge, auf die sie zugreifen können.

Für Entwickler, die 2026 agentengestützte 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 pflegen, die zu einer Belastung wird, wenn Ihr Produkt wächst.

Weiterführende Lektüre:

• KI-Orchestrierungs-Frameworks im Vergleich
• MCP vs. Skills: Was sollten Sie verwenden?
• AnyCap-Fähigkeiten
• AG-UI GitHub-Repository