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.

ag-ui-protocolag-ui

Features

Star history