ag-ui-protocol/ag-ui
Ag Ui
ag-ui is an agent-frontend interoperability layer and communication protocol designed to connect AI agent backends with web and mobile user interfaces. It provides a standardized event-driven framework for exchanging messages, session state, and tool calls, utilizing a generative UI framework to render dynamic interface components and structured content triggered by an agent.
The project distinguishes itself through an SSE-based event streamer that delivers real-time incremental model responses and reasoning telemetry. It enables bi-directional state synchronization and allows remote agents to trigger local client-side tool execution for accessing device hardware or private data.
The system covers a broad range of capabilities including session and conversation context management, schema-driven tool integration, and human-in-the-loop coordination. It also provides protocol event inspection for debugging and supports API request authentication via bearer tokens, API keys, or basic authentication.
A command-line tool is available for project scaffolding to quickly establish connectivity between clients and servers.
Features
- Agent-Frontend Integration Frameworks - Connects AI agent backends to web and mobile user interfaces using a standardized event-driven protocol.
- Agent-Client Communication Protocols - Implements a standardized event-driven communication protocol for connecting user applications to AI agent backends.
- Agent Communication Protocols - Provides a standardized event-driven protocol connecting AI agent backends with user-facing applications.
- Agent Event UI Mappings - Maps structured agent events to dynamic frontend components to render real-time user interfaces.
- Backend Base Frameworks - Provides a structured framework of base classes and message factories for building intelligent agent backends.
- Streaming Response Protocols - Provides a mechanism to send messages to agent backends and receive real-time streaming updates on response content.
- Frontend Interoperability Layers - Links custom agent backends to a standardized communication layer for seamless frontend interoperability.
- Agent-Triggered UI Components - Creates dynamic user interface components that are triggered and updated in real time by an AI agent.
- Client-Side Tool Execution - Allows remote agents to trigger local functions on the user device for hardware or data access.
- Context Memory Management - Manages application state and interaction history to maintain context across AI chat sessions.
- Conversation Context Tracking - Transmits conversation history to the backend to enable context-aware multi-turn interactions.
- Conversation State Management - Synchronizes chat history and application context between frontend and backend for session continuity.
- Event-Driven Agent Interfaces - Provides a framework for connecting agent backends to interfaces using unified message factories and base classes.
- External Tool Integration - Connects agents to functional tools with defined input and output schemas to perform real-world tasks.
- Local Tool Execution - Executes functions on the client device in response to agent requests to access local hardware or private data.
- Model Response Streaming - Delivers model output through start, content, and end events for real-time user visibility.
- Agent Response Streams - Streams AI agent responses and reasoning telemetry incrementally for real-time client visibility.
- Agent Event Schemas - Establishes common event structures for text messages and tool calls to ensure consistent interactions.
- Client-Side Tool Execution Bridges - Synchronizes application state and executes local client-side tools in response to remote agent requests.
- Bi-Directional State Synchronizations - Maintains consistent application state between the backend agent and frontend UI through a continuous event stream.
- SSE-Based - Uses Server-Sent Events to stream real-time model responses and agent telemetry from server to client.
- Real-time Event Streams - Implements bidirectional event streaming between backends and frontends for exchanging messages and state.
- Server-Sent Events - Uses Server-Sent Events to deliver real-time streaming updates and incremental model responses.
- Tool Schema Mappings - Translates function signatures into JSON schemas to connect agent backends with executable tools.
- Agent Protocol Client Interfaces - Provides the interface compatibility layer for web and mobile applications to consume standardized agent event protocols.
- Generative UI - Renders dynamic user interface components and structured content triggered by the AI agent.
- Generative UI Frameworks - Offers a system for rendering dynamic user interface components triggered by an AI agent during conversation.
- Frontend Tool Bindings - Directly connects agent capabilities to frontend-side tools to enhance the user experience.
- Human-in-the-Loop Workflows - Coordinates interactions where humans provide real-time feedback or approval for automated agent actions.
- Agent Activity Synchronization - Enables real-time event streaming from remote servers to synchronize agent activity with a local application.
- Structured Event Streams - Delivers rich, event-driven structured data from agent backends to clients for real-time interaction.
- Session Context Provisioning - Injects current application state and user data into the agent context during active sessions.
- Agent SSE Connection Management - Provides SSE connectivity with automatic reconnection, timeout handling, and authentication for agent connections.
- Event-Driven Architectures - Implements a standardized system of typed events that synchronizes agent state and user interactions.
- Reasoning Chain Visualizers - Captures and displays internal thinking process events to visualize the agent's reasoning steps in real time.
