AG-UI (the Agent-User Interaction Protocol) is CopilotKit's open, lightweight, event-based protocol that standardises how AI agents connect to user-facing applications. The frontend sends a run request carrying the conversation, shared state, and the tools it offers, and the agent streams back a sequence of typed events over SSE or WebSockets. Created by CopilotKit and launched in May 2025, it is MIT-licensed and lives at ag-ui-protocol/ag-ui on GitHub.

What is the difference between AG-UI and A2UI?

They sit at different layers. A2UI is Google's declarative payload format — the agent returns a JSON component tree the client renders. AG-UI is CopilotKit's event-based wire protocol between an agent backend and a frontend, so an A2UI payload can be delivered over AG-UI (or over A2A). Payload versus pipe.

How does AG-UI relate to MCP and A2A?

They are complementary layers of one stack, not competitors. MCP (from Anthropic) standardises how an agent reaches tools and data; A2A (from Google) standardises how agents talk to each other; AG-UI (from CopilotKit) standardises how an agent run reaches the person using the app. The same agent typically speaks both MCP and AG-UI.

Do I need special infrastructure to run AG-UI?

No. AG-UI is an abstraction layer over standard web protocols — HTTP with Server-Sent Events (SSE) or WebSockets — so it needs no exotic infrastructure. An agent backend exposes an endpoint, the frontend sends a run request, and the backend streams typed events back. You deploy it on ordinary web infrastructure you already run.

What is AG-UI? The Agent-User Interaction protocol

What is AG-UI?

AG-UI (the Agent-User Interaction Protocol) is CopilotKit’s open protocol for the agent-to-user leg of the stack. The docs define it as “an open, lightweight, event-based protocol that standardizes how AI agents connect to user-facing applications” — the general-purpose, bi-directional connection between a user-facing application and any agentic backend. The docs frame a three-layer stack: MCP (from Anthropic) for agent↔tools and data, A2A (from Google) for agent↔agent, and AG-UI (from CopilotKit) for agent↔user. The three are complementary layers, not competitors.

AG-UI was created by CopilotKit, emerging from its partnership work with LangGraph and CrewAI, and launched in May 2025. The project is MIT-licensed and lives at ag-ui-protocol/ag-ui on GitHub — as of 17 July 2026 it has gathered 14.8k stars across 32 releases, with full documentation covering the event vocabulary, SDKs, and framework integrations.

How does AG-UI work?

An agent backend exposes an endpoint. The frontend sends a run request carrying the conversation so far, any shared state, and the tools the frontend itself offers; the backend streams back a sequence of typed events over standard web transport — Server-Sent Events (SSE) or WebSockets. AG-UI is an abstraction layer over those protocols, so it needs no exotic infrastructure. Every event carries a type, an optional timestamp, and an optional rawEvent (the original framework event, if the event was transformed). Wire-format type strings are SCREAMING_SNAKE_CASE (e.g. RUN_STARTED); the SDK classes use PascalCase (e.g. RunStarted). A typical run streamed over SSE looks like this:

data: {"type":"RUN_STARTED","threadId":"thr_1","runId":"run_42"}

data: {"type":"TEXT_MESSAGE_START","messageId":"msg_1","role":"assistant"}

data: {"type":"TEXT_MESSAGE_CONTENT","messageId":"msg_1","delta":"Found 3 flights…"}

data: {"type":"TEXT_MESSAGE_END","messageId":"msg_1"}

data: {"type":"STATE_DELTA","delta":[{"op":"replace","path":"/search/status","value":"complete"}]}

data: {"type":"RUN_FINISHED","threadId":"thr_1","runId":"run_42"}

The protocol defines around 30 standard events across seven categories, plus draft meta-events still under development, as documented in the events reference:

Category	Events
Lifecycle	`RUN_STARTED`, `RUN_FINISHED`, `RUN_ERROR`, `STEP_STARTED`, `STEP_FINISHED`
Text messages	`TEXT_MESSAGE_START`, `TEXT_MESSAGE_CONTENT`, `TEXT_MESSAGE_END`, `TEXT_MESSAGE_CHUNK`
Tool calls	`TOOL_CALL_START`, `TOOL_CALL_ARGS`, `TOOL_CALL_END`, `TOOL_CALL_RESULT`, `TOOL_CALL_CHUNK`
State	`STATE_SNAPSHOT`, `STATE_DELTA`, `MESSAGES_SNAPSHOT`
Activity	`ACTIVITY_SNAPSHOT`, `ACTIVITY_DELTA`
Reasoning	`REASONING_START`, `REASONING_END`, `REASONING_MESSAGE_START`, `REASONING_MESSAGE_CONTENT`, `REASONING_MESSAGE_END`, `REASONING_MESSAGE_CHUNK`, `REASONING_ENCRYPTED_VALUE`
Special	`RAW`, `CUSTOM`

What can AG-UI do beyond streaming text?

Streaming text deltas are the baseline, but AG-UI’s event model carries much more. Shared state flows both ways between agent and UI through full STATE_SNAPSHOT events plus STATE_DELTA deltas expressed as JSON Patch (RFC 6902) operations, so the frontend can render a live view of what the agent is working on. Human-in-the-loop interrupts let a run pause so a person can approve, edit, retry, or escalate mid-flight. Generative UI means the agent’s output can render as real UI components, not just text. Frontend tool execution lets the agent call tools that run in the user’s browser, with typed handoffs. Agent steering lets the user redirect a run mid-flight, and multimodality carries files, images, audio, and transcripts alongside text.

Is AG-UI the same as A2UI?

No — and the near-identical names trip people up. A2UI is Google’s declarative payload format: the agent returns a JSON component tree that the host renders as interactive UI. AG-UI is CopilotKit’s event-based wire protocol between an agent backend and a frontend. They sit at different layers — an A2UI payload can be delivered over AG-UI (or over A2A). Payload versus pipe.

Which frameworks support AG-UI?

AG-UI ships SDKs in TypeScript and Python — CopilotKit remains the primary client implementation — with community SDKs in Kotlin, Go, Dart, Java, and Rust, and .NET and Nim in progress. Framework integrations fall into three tiers. The partnership integrations are LangGraph and CrewAI. The first-party integrations include Microsoft Agent Framework, Google ADK, AWS Strands Agents, AWS Bedrock AgentCore, Mastra, Pydantic AI, Agno, LlamaIndex, and AG2. Still in progress are the OpenAI Agent SDK, Cloudflare Agents, and AWS Bedrock Agents. The AG-UI Dojo is the official demo environment showcasing per-framework implementations.

Does Agent Ready check for AG-UI?

Not yet — and for a structural reason. AG-UI defines no publisher-side static discovery artifact: no /.well-known/ path, no manifest, no schema a crawler can fetch and validate. It is a runtime conversation between a deployed agent backend and a running frontend. Agent Ready’s protocol checks are discover-then-validate over static artifacts — MCP server cards, A2A Agent Cards, agents.json, llms.txt, and the rest in the spec registry — so there is nothing for a static scanner to probe. (The same wall applies to WebMCP’s runtime-registered tools.) If AG-UI ever ships a static discovery surface, a discover-then-validate check would follow — and sites that publish nothing are never penalised.

To see where your site stands across the signals Agent Ready can measure today, run a full agent-readability scan.

Frequently asked questions

What is AG-UI?: AG-UI (the Agent-User Interaction Protocol) is CopilotKit's open, lightweight, event-based protocol that standardises how AI agents connect to user-facing applications. The frontend sends a run request carrying the conversation, shared state, and the tools it offers, and the agent streams back a sequence of typed events over SSE or WebSockets. Created by CopilotKit and launched in May 2025, it is MIT-licensed and lives at ag-ui-protocol/ag-ui on GitHub.
What is the difference between AG-UI and A2UI?: They sit at different layers. A2UI is Google's declarative payload format — the agent returns a JSON component tree the client renders. AG-UI is CopilotKit's event-based wire protocol between an agent backend and a frontend, so an A2UI payload can be delivered over AG-UI (or over A2A). Payload versus pipe.
How does AG-UI relate to MCP and A2A?: They are complementary layers of one stack, not competitors. MCP (from Anthropic) standardises how an agent reaches tools and data; A2A (from Google) standardises how agents talk to each other; AG-UI (from CopilotKit) standardises how an agent run reaches the person using the app. The same agent typically speaks both MCP and AG-UI.
Which frameworks support AG-UI?: AG-UI ships SDKs in TypeScript and Python — CopilotKit is the primary client implementation — with community SDKs in Kotlin, Go, Dart, Java, and Rust, and .NET and Nim in progress. Partnership integrations cover LangGraph and CrewAI; first-party integrations include Microsoft Agent Framework, Google ADK, AWS Strands Agents, AWS Bedrock AgentCore, Mastra, Pydantic AI, Agno, LlamaIndex, and AG2. The OpenAI Agent SDK, Cloudflare Agents, and AWS Bedrock Agents are in progress.
Do I need special infrastructure to run AG-UI?: No. AG-UI is an abstraction layer over standard web protocols — HTTP with Server-Sent Events (SSE) or WebSockets — so it needs no exotic infrastructure. An agent backend exposes an endpoint, the frontend sends a run request, and the backend streams typed events back. You deploy it on ordinary web infrastructure you already run.
Does Agent Ready check for AG-UI?: Not yet. AG-UI defines no publisher-side static discovery artifact — no /.well-known/ path, no manifest, no schema a crawler can fetch — so there is nothing for a static scanner to probe; it is a runtime conversation between a deployed agent backend and a running frontend. Agent Ready's protocol checks are discover-then-validate over static artifacts, and if AG-UI ever ships a static discovery surface a check would follow. Sites that publish nothing are never penalised.