​
The Agent–User Interaction (AG-UI) Protocol

A horizontal standard to bring AI agents into user‑facing frontend applications. AG‑UI is the boundary layer where AI agents and users meet. It standardizes how agent state, UI intents, and user interactions flow between your model/agent runtime and your app’s frontend—so you can ship reliable, debuggable, user‑friendly agentic features fast.

​
Built with the ecosystem

First‑party partnerships & integrations AG‑UI works across leading agent frameworks and frontend stacks, with shared vocabulary and primitives that keep your UX consistent as your agents evolve.
AG-UI Architecture Illustration

​
Building blocks (today & upcoming)

Streaming chat
Token‑level and tool‑event streaming for responsive UIs.
Static generative UI
Render model output into stable, typed components.
Declarative generative UI
Let agents propose UI trees; app decides what to mount.
Frontend tools
Safe, typed tool calls that bridge agent logic to app actions.
Interrupts & human‑in‑the‑loop
Pause, approve, edit, or steer mid‑flow.
In‑chat + in‑app interactions
Chat commands alongside regular app controls.
Attachments & multimodality
Files, images, audio, and structured payloads.
Thinking steps
Expose summaries/redactions of chain‑of‑thought artifacts to users, safely.
Sub‑agent calls
Orchestrate nested agents and delegate specialized tasks.
Agent steering
Guardrails, policies, and UX affordances to keep agents on track.

​
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

​
Why Agentic Apps need AG-UI

Agentic apps break the classic request/response contract. Agents run for longer, stream work as they go, and make nondeterministic choices that can affect your UI and state. AG‑UI defines a clean, observable boundary so frontends remain predictable while agents stay flexible.

​
What’s hard about user‑facing agents?

  • Agents are long‑running and stream intermediate work—often across multi‑turn sessions.
  • Agents are nondeterministic and can control UI in ways that must be supervised.
  • Apps must mix structured + unstructured IO (text, voice, tool calls, state updates).
  • Agents need composition: agents call sub‑agents, often non-deterministically.
With AG‑UI, these become deliberate, well‑typed interactions rather than ad‑hoc wiring.

​
Supported Frameworks

AG-UI was born from an initial partnership between CopilotKit, LangGraph and CrewAI - and is steadily gaining integrations across the wider AI developer ecosystem.
FrameworkDocsDemos
LangGraphDocumentationLive Demo
CrewAIDocumentationLive Demo
MastraDocumentationLive Demo
AG2DocumentationComing Soon
AgnoDocumentationLive Demo
LlamaIndexDocumentationLive Demo
Pydantic AIDocumentationLive Demo
Google ADKDocumentationLive Demo
AWS Bedrock AgentsIn ProgressComing Soon
AWS Strands AgentsIn ProgressComing Soon
Vercel AI SDKIn ProgressComing Soon
OpenAI Agent SDKIn ProgressComing Soon
Cloudflare AgentsOpen to ContributionsComing Soon

​
Comparison with other protocols

AG-UI focuses explicitly and specifically on the agent-user interactivity layer. It does not compete with protocols such as A2A (Agent-to-Agent protocol) and MCP (Model Context Protocol). For example, the same agent may communicate with another agent via A2A while communicating with the user via AG-UI, and while calling tools provided by an MCP server. These protocols serve complementary purposes in the agent ecosystem:
  • AG-UI: Handles human-in-the-loop interaction and streaming UI updates
  • A2A: Facilitates agent-to-agent communication and collaboration
  • MCP: Standardizes tool calls and context handling across different models

​
Quick Start

Choose the path that fits your needs:

AG-UI Middleware Connectors

Connect AG-UI with existing protocols, in process agents or custom solutions using TypeScript

AG-UI Compatible Servers

Implement AG-UI compatible servers using Python or TypeScript

​
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

​
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

Transports

Learn about AG-UI’s communication mechanism

​
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: