AG-UI Overview

The Agent–User Interaction (AG-UI) Protocol

AG-UI is an open, lightweight, event-based protocol that standardizes how AI agents connect to user-facing applications.

Built for simplicity and flexibility, it standardizes how agent state, UI intents, and user interactions flow between your model/agent runtime and user-facing frontend applications—to allow application developers to ship reliable, debuggable, user‑friendly agentic features fast while focusing on application needs and avoding complex ad-hoc wiring.

---

Building blocks (today & upcoming)

Streaming chat

Live token and event streaming for responsive multi turn sessions, with cancel and resume.

Multimodality

Typed attachments and real time media (files, images, audio, transcripts); supports voice, previews, annotations, provenance.

Generative UI, static

Render model output as stable, typed components under app control.

Generative UI, declarative

Small declarative language for constrained yet open-ended agent UIs; agents propose trees and constraints, the app validates and mounts.

Shared state

(Read-only & read-write). Typed store shared between agent and app, with streamed event-sourced diffs and conflict resolution for snappy collaboration.

Thinking steps

Visualize intermediate reasoning from traces and tool events; no raw chain of thought.

Frontend tool calls

Typed handoffs from agent to frontend-executed actions, and back.

Backend tool rendering & side effects

Visualize backend tool outputs in app and chat, emit side effects as first-class events.

Interrupts (human in the loop)

Pause, approve, edit, retry, or escalate mid flow without losing state.

Sub-agents and composition

Nested delegation with scoped state, tracing, and cancellation.

Agent steering

Dynamically redirect agent execution with real-time user input to guide behavior and outcomes.

Tool output streaming

Stream tool results and logs so UIs can render long-running effects in real time.

Custom events

Open-ended data exchange for needs not covered by the protocol.

---

Why Agentic Apps need AG-UI

Agentic applications break the simple request/response model that dominated frontend-backend development in the pre-agentic era: a client makes a request, the server returns data, the client renders it, and the interaction ends.

The requirements of user‑facing agents

While agents are just software, they exhibit characteristics that make them challenging to serve behind traditional REST/GraphQL APIs:

• Agents are long‑running and stream intermediate work—often across multi‑turn sessions.
• Agents are nondeterministic and can control application UI nondeterministically.
• Agents simultanously mix structured + unstructured IO (e.g. text & voice, alongside tool calls and state updates).
• Agents need user-interactive composition: e.g. they may call sub‑agents, often recursively.
• And more…

AG-UI is an event-based protocol that enables dynamic communication between agentic frontends and backends. It builds on top of the foundational protocols of the web (HTTP, WebSockets) as an abstraction layer designed for the agentic age—bridging the gap between traditional client-server architectures and the dynamic, stateful nature of AI agents.

The AI protocol landscape

AG-UI has emerged as the 3rd leg of the AI protocol landscape:

• MCP: Connects agents to tool and to context.
• A2A: Connects agents to other agents.
• AG-UI: Connects agents to users (through user-facing applications)

These protocols are complimentary and have distinct technical goals; a single agent can and often does use all 3 simultanously. Where these protocols intersect, there are opportunities for seamless handshakes facilitating interoperability—work on these integration points is actively ongoing. AG-UI’s mandate is to support the full set of building blocks required by modern agentic applications.

---

AG-UI in action

You can see demo apps of the AG-UI features with the framework of your choice, with preview, code and walkthrough docs in the AG-UI Dojo

---

Supported Integrations

AG-UI was born from CopilotKit’s initial partnership with LangGraph and CrewAI - and brings the incredibly popular agent-user-interactivity infrastructure to the wider agentic ecosystem.

Direct to LLM

Framework	Status	AG-UI Resources
Direct to LLM	Supported	Docs

Agent Framework - Partnerships

Framework	Status	AG-UI Resources
LangGraph	Supported	Docs, Demos
Google ADK	Supported	Docs, Demos
CrewAI	Supported	Docs, Demos

Agent Framework - 1st Party

Framework	Status	AG-UI Resources
Mastra	Supported	Docs, Demos
Pydantic AI	Supported	Docs, Demos
Agno	Supported	Docs, Demos
LlamaIndex	Supported	Docs, Demos
AG2	Supported	Docs
AWS Bedrock Agents	In Progress	–
AWS Strands Agents	In Progress	–
Microsoft Agent Framework	In Progress	–

Agent Framework - Community

Framework	Status	AG-UI Resources
Vercel AI SDK	Supported	Docs
OpenAI Agent SDK	In Progress	–
Cloudflare Agents	In Progress	–

Agent Interaction Protocols

Protocol	Status	AG-UI Resources	Integrations
A2A Middleware	Supported	Docs	Partnership

SDKs

SDK	Status	AG-UI Resources	Integrations
Kotlin	Supported	Getting Started	Community
Golang	Supported	Getting Started	Community
Java	Supported	Getting Started	Community
Rust	Supported	Getting Started	Community
.NET	In Progress	PR	Community
Nim	In Progress	PR	Community
Dart	In Progress	PR	Community
Flowise	In Progress	GitHub Source	Community
Langflow	In Progress	GitHub Source	Community

Clients

Client	Status	AG-UI Resources	Integrations
CopilotKit	Supported	Getting Started	1st Party
Terminal + Agent	Supported	Getting Started	Community
React Native	Help Wanted	GitHub Source	Community

---

Quick Start

Choose the path that fits your needs:

Build agentic applications

Build agentic applications powered by AG-UI compatible agents.

Build new AG-UI integrations

Build integrations for new agent frameworks, custom in-house solutions, or use AG-UI without any agent framework.

Build AG-UI compatible clients

Build new clients for AG-UI-compatible agents (web, mobile, slack, messaging, etc.)

Explore AG-UI

Dive deeper into AG-UI’s core concepts and capabilities:

Core architecture

Understand how AG-UI connects agents, protocols, and front-ends

Events

Learn about AG-UI’s event-driven protocol

Resources

Explore guides, tools, and integrations to help you build, optimize, and extend your AG-UI implementation. These resources cover everything from practical development workflows to debugging techniques.

Developing with Cursor

Use Cursor to build AG-UI implementations faster

Troubleshooting AG-UI

Fix common issues when working with AG-UI servers and clients

Contributing

Want to contribute? Check out our Contributing Guide to learn how you can help improve AG-UI.

Support and Feedback

Here’s how to get help or provide feedback:

• For bug reports and feature requests related to the AG-UI specification, SDKs, or documentation (open source), please create a GitHub issue
• For discussions or Q&A about the AG-UI specification, use the specification discussions
• For discussions or Q&A about other AG-UI open source components, use the organization discussions