TL;DR
AG-UI (the Agent-User Interaction Protocol, ag-ui-protocol/ag-ui) is an open, event-based protocol for the last mile of an agent app: the connection between the agent backend and the screen a person looks at. Your app sends one RunAgentInput (messages, frontend tools, shared state, context). The agent streams back typed events: text tokens, tool calls, state patches, reasoning, subagent activity and a terminal “run finished” event. Any client that speaks AG-UI can render any agent that speaks it, whichever framework built the agent.
Last verified: November 21, 2026, against the GitHub repository, the 1.0 spec, npm and PyPI.
Facts as of November 21, 2026:
- 20,900 GitHub stars, 2,134 forks; repository created May 7, 2025
- MIT license; created by CopilotKit and developed in the open
- Protocol 1.0 was released on September 17, 2026, with a frozen spec and a JSON Schema
- Current packages:
@ag-ui/clientand@ag-ui/core1.0.5 on npm,ag-ui-protocol1.0.0 on PyPI; the repo publishes dated releases, the latest beingrelease/2026-11-17 - 317 open issues (plus 282 open pull requests); about 195 contributors listed by GitHub
- It gained roughly 3,600 stars in the past week on GitHub Trending
Not run by us: our hands-on lab (a throwaway GitHub Actions container) could not start on November 21, 2026, because GitHub refused the job over a billing limit on the account. We had prepared a run of the README’s Python server and TypeScript client; none of it executed. Everything below comes from the repository, the 1.0 specification, the SDK changelogs and CopilotKit’s announcement.
Our verdict: AG-UI is the most complete answer so far to “how does my agent talk to my frontend?” The 1.0 spec is careful work: it separates unknown from malformed input, pins down how runs end, and handles human-in-the-loop pauses without holding a connection open. Adopt it if you build a product UI on top of LangGraph, Mastra, Pydantic AI, Google ADK or similar, and you are tired of writing a custom streaming layer per framework. Skip it if one backend talks to one frontend you own and a plain SSE stream already works. Note one thing: in practice the ecosystem still leans on CopilotKit, the company behind it.
What problem it solves
A normal web API is request and response. An agent is not. In a single turn it may stream tokens, call a tool halfway through a sentence, update some shared state, stop to ask a human for approval, and hand part of the job to a subagent. Every agent framework exposes that stream in its own shape. A frontend team that supports two frameworks ends up maintaining two parsers, two sets of loading states and two ideas of what “done” means.
AG-UI swaps that for one event vocabulary. The README puts it in a stack with two other protocols: MCP gives agents tools and context, A2A lets agents work with other agents, and AG-UI brings agents to users. A single agent can use all three. The project also answers the question people ask most often: AG-UI is not a UI description format. A2UI, MCP Apps and Open-JSON-UI describe what interface an agent wants to show. AG-UI is the runtime pipe that carries those payloads, along with everything else, between the agent and the app.
We covered two products built on it earlier: OpenBot, CopilotKit’s governed AI-coworker platform, which accepts any AG-UI agent as a “Bot”, and OpenMuse, its self-hosted personal agent. This review is about the protocol underneath both.
How it works
The model is small. A run looks like this:
- The client sends
POSTto the agent endpoint with aRunAgentInputJSON body:threadId,runId,messages, thetoolsthe frontend offers,state,contextandforwardedProps. - The agent answers
200with an event stream. Each event is one JSON object with atype. - The stream ends with a terminal event,
RUN_FINISHEDorRUN_ERROR.
Only the run-lifecycle events are required, so a minimal agent emits five events and grows from there. AG-UI 1.0 defines 31 event types in eight families:
| Family | Events |
|---|---|
| Runs and steps | RUN_STARTED, RUN_FINISHED, RUN_ERROR, STEP_STARTED, STEP_FINISHED |
| Text messages | TEXT_MESSAGE_START, _CONTENT, _END, _CHUNK |
| Tool calls | TOOL_CALL_START, _ARGS, _END, _RESULT, _CHUNK |
| State | STATE_SNAPSHOT, STATE_DELTA (JSON Patch), MESSAGES_SNAPSHOT |
| Reasoning | REASONING_START, REASONING_MESSAGE_*, REASONING_ENCRYPTED_VALUE, REASONING_END |
| Activity | ACTIVITY_SNAPSHOT, ACTIVITY_DELTA |
| Subagents | SUBAGENT_STARTED, SUBAGENT_FINISHED, SUBAGENT_ERROR |
| Passthrough | RAW, CUSTOM |
The protocol does not depend on one transport. The spec defines two bindings: HTTP + SSE (JSON events in data: lines) and HTTP + Protobuf (4-byte length-prefixed binary frames generated from the same schema). Middleware can adapt events from any other source.
Two design choices stand out. Frontend tools run in the browser: the app lists them in RunAgentInput.tools, the agent emits a tool call, and the app runs it and returns the result. Shared state is a typed store that both sides read and write. A full STATE_SNAPSHOT sets it, and STATE_DELTA events patch it with RFC 6902 JSON Patch, so a long-running agent can update one field without resending the whole document.
The smallest real example
The README’s own quick start is a 30-line Python agent and a short TypeScript client, and it needs no API key. Here is the agent (Python 3.9+, pip install ag-ui-protocol fastapi uvicorn):
# server.py
import uuid
from fastapi import FastAPI, Request
from fastapi.responses import StreamingResponse
from ag_ui.core import (
PROTOCOL_VERSION, RunAgentInput, RunStartedEvent, RunFinishedEvent,
TextMessageStartEvent, TextMessageContentEvent, TextMessageEndEvent,
)
from ag_ui.encoder import EventEncoder
app = FastAPI()
@app.post("/")
async def run_agent(input_data: RunAgentInput, request: Request):
encoder = EventEncoder(accept=request.headers.get("accept"))
async def events():
yield encoder.encode(RunStartedEvent(
thread_id=input_data.thread_id,
run_id=input_data.run_id,
protocol_version=PROTOCOL_VERSION,
))
message_id = str(uuid.uuid4())
yield encoder.encode(TextMessageStartEvent(message_id=message_id, role="assistant"))
for chunk in ["Hello ", "from ", "AG-UI!"]:
yield encoder.encode(TextMessageContentEvent(message_id=message_id, delta=chunk))
yield encoder.encode(TextMessageEndEvent(message_id=message_id))
yield encoder.encode(RunFinishedEvent(thread_id=input_data.thread_id, run_id=input_data.run_id))
return StreamingResponse(events(), media_type=encoder.get_content_type())
Start it with uvicorn server:app --port 8000. And here is the client (Node.js 20+, npm install @ag-ui/client tsx):
// client.ts
import { HttpAgent } from "@ag-ui/client";
const agent = new HttpAgent({ url: "http://localhost:8000/" });
agent.addMessage({ id: crypto.randomUUID(), role: "user", content: "Hi there!" });
await agent.runAgent({}, {
onRunStartedEvent: ({ event }) => console.log(`run started (AG-UI ${event.protocolVersion})`),
onTextMessageContentEvent: ({ event }) => { process.stdout.write(event.delta); },
onRunFinishedEvent: () => console.log("\nrun finished"),
});
According to the README, npx tsx client.ts prints Hello from AG-UI! streamed chunk by chunk. You can then swap the server for any supported framework and the client stays the same. We did not see this happen ourselves (see the note at the top).
Note the EventEncoder(accept=...) line. The same server code serves SSE or Protobuf depending on the client’s Accept header. That is the transport-agnostic design showing up in ten characters of code.
If you would rather not write any of this by hand, npx create-ag-ui-app@latest scaffolds a frontend (CopilotKit on Next.js, or a terminal client) wired to the agent framework you pick. The generated templates call OpenAI, so they need an OPENAI_API_KEY.
What 1.0 changed
Before 1.0, AG-UI defined shapes, and the behaviour lived in the TypeScript client. Whatever that client did was the protocol. The 1.0 release (September 17, 2026) writes the rules down in BCP 14 “MUST/SHOULD” language. The JSON Schema is authoritative for structure and the spec for behaviour, and the TypeScript, Python and .NET SDK types are now generated from the schema. CopilotKit’s announcement says teams at Anthropic, Pydantic AI and TanStack gave feedback on the public draft. The changes that matter most:
- Runs say how they ended.
RUN_FINISHEDgets an optionaloutcome: success, interrupt or cancelled. A run the user stopped no longer looks like one that completed or crashed. - Interrupts for human-in-the-loop. When an agent needs approval, the run ends with
outcome: { type: "interrupt", interrupts: [...] }. Each interrupt carries anid, areason, an optionalresponseSchemaand an optionalexpiresAt. The client starts a new run on the same thread with aresumearray (resolvedorcancelled, plus a payload). No connection sits open waiting for a human who went to lunch, and that is the right call. - Subagents. Every event a subagent produces carries a
subagentRunId, so a UI can put the flight-search subagent and the hotel-search subagent in separate cards instead of mixing their tokens in one bubble. - Reasoning replaces “thinking”. The
THINKING_*events are retired in favour ofREASONING_*, includingREASONING_ENCRYPTED_VALUEfor provider artefacts the client stores and sends back unread. - Token usage on
RUN_FINISHED, with rules for input, output, cached and reasoning tokens, and subagent tokens counted toward the parent run. - Multimodal tool results.
TOOL_CALL_RESULT.contentcan be a list of parts (text, image, audio, video, document), so an invoice tool can return the PDF itself. - Unknown vs malformed, defined. An unknown event or field from a newer peer is dropped or stripped with a warning. A malformed value of a known field is fatal. This one rule lets old clients and new agents coexist.
Compatibility goes both ways, according to the migration guide. A 0.x agent works with a 1.0 client, because the TypeScript client has an always-on compatibility boundary that translates retired shapes. A 1.0 agent works with a 0.x client, because everything new is optional or a new event type that old clients ignore. The shims have an end date: DEPRECATIONS.md says they expire on September 17, 2027, after which the old shapes stop working.
Ecosystem: who speaks it
The README lists integrations for LangChain/LangGraph, CrewAI, Microsoft Agent Framework, Google ADK (Python and JS), Google Antigravity, AWS Strands Agents, Mastra, Pydantic AI, Agno, LlamaIndex, AG2, the Claude Agent SDK, Claude Managed Agents, IBM watsonx Orchestrate, Langroid and OpenAI Agents, and the repo’s integrations/ folder also holds a Vercel AI SDK package. Community packages cover Spring AI, Cloudflare Agents, Genkit (Go) and Omnara. Amazon Bedrock AgentCore documents an AG-UI runtime. The project says AG-UI is adopted by Google, Microsoft, Amazon and Oracle; that is its claim, but the integration code for each one is in the repo’s integrations/ folder, which you can check.
Official SDKs exist for TypeScript, Python and .NET, with community SDKs in Kotlin, Go, Java, Dart, Rust, Ruby, C++ and Swift. Middleware bridges to A2A, MCP, MCP Apps and A2UI. The AG-UI Dojo runs each feature as a live demo per framework, so you can compare integrations before you commit.
Community reactions
Most public discussion comes from AG-UI contributors themselves. A May 2026 r/AI_Agents post titled “Google, Microsoft, and AWS all support AG-UI now” was written by one of the project’s contributors, and several 2025 launch posts in other subreddits came from the project side too. Independent voices are fewer and more mixed. A May 2025 r/AI_Agents commenter called the spec “a good start” and the project “extremely earl[y] stage”, adding: “Lot more refinements and security considerations to be built into this.” A March 2026 r/LangChain thread on generative UI says AG-UI is roughly the right shape, but one user said a “pure” Python backend was hard to get running and they ended up putting a TypeScript shim in front of their LangGraph agent. The 1.0 Python SDK and the generated models are meant to close that gap. We have not seen independent reports since 1.0 that confirm it does.
Activity is healthy: the last push was November 20, 2026, and dated releases ship several times a week. The flip side is 317 open issues and 282 open PRs across one large monorepo.
Honest limitations
- CopilotKit-centric in practice. The protocol is MIT and the integrations are real, but the README’s scaffolder outputs a CopilotKit frontend, the docs point to CopilotKit’s docs for most framework guides, and the security contact is a CopilotKit address. There is no foundation or independent governance body. If the company changes direction, the spec stays frozen, but the SDKs and integrations depend on its team.
- No auth in the protocol. The transport spec says authentication and authorization belong to the binding and the application; AG-UI defines no credential. That is a reasonable layering choice, but it means every deployment has to put its own auth, rate limiting and tenant isolation in front of the agent endpoint. A frontend that offers tools to an agent is also a trust boundary you have to think through.
- No stream resumption over SSE. The spec says plainly that the HTTP + SSE binding has no resumption: a broken stream cannot be re-entered, and a retry is a new run with a new
runId. Mobile clients on flaky networks will need app-level handling. - Deprecation clock. 0.x shapes stop working after September 17, 2027. If you built on early AG-UI, you have a migration due within the next ten months.
- Not run by us. We could not execute even the hello-world example today, so this review cannot speak to install friction, SDK bugs or performance.
How it compares
| AG-UI | Plain SSE / WebSocket | A2UI / MCP Apps | |
|---|---|---|---|
| What it is | Agent↔app runtime protocol | DIY transport | Generative UI description specs |
| Framework-neutral | Yes, about 20 integrations | Whatever you build | Yes |
| Human-in-the-loop | Interrupt outcome + resume | You design it | Not its job |
| Shared state | Snapshot + JSON Patch | You design it | Not its job |
| Formal spec | 1.0 JSON Schema + normative rules | No | Yes |
| Best for | Multi-framework products | One backend, one frontend | Describing what UI to render |
AG-UI and A2UI are complementary, not competing. AG-UI carries A2UI payloads through a dedicated middleware.
FAQ
What is AG-UI in one sentence?
AG-UI is an open, MIT-licensed protocol that defines how an AI agent backend streams typed events (text, tool calls, state, reasoning, subagents, run outcomes) to a user-facing app, so any AG-UI client can render any AG-UI agent.
How is AG-UI different from MCP and A2A?
MCP connects an agent to tools and data, A2A connects agents to other agents, and AG-UI connects an agent to the person using an app. One agent can use all three at once, and AG-UI ships middleware that bridges to both.
Do I need CopilotKit to use AG-UI?
No. The Python, TypeScript and .NET SDKs work alone. The README’s own example is a FastAPI server and a bare HttpAgent client with no CopilotKit code. CopilotKit is the most complete ready-made frontend client, though, and the scaffolder uses it by default.
Will my 0.x AG-UI agent break on 1.0?
Not yet. The project says 1.0 is backwards compatible in both directions, and the TypeScript client translates retired shapes such as THINKING_* events. Those shims expire on September 17, 2027, so plan the migration before then.
Is AG-UI production-ready?
The spec is frozen and the SDKs are at 1.0, and Amazon Bedrock AgentCore and Microsoft Agent Framework ship support. But the protocol leaves auth, rate limiting and stream resumption to you, and the repo has 317 open issues. Treat it as a stable contract with integrations that are still settling.
Verdict
AG-UI deserves its trending spot. The 1.0 spec is careful work: interrupts that end the run instead of holding a socket open, attribution for subagents, clear rules for unknown versus malformed input, and an SSE binding that states what it does not do. For a team putting a real product UI on top of one or more agent frameworks, it removes a whole layer of custom code and gives you a contract you can test against.
Go in knowing that adoption runs through CopilotKit, that security sits outside the protocol, and that the 0.x compatibility window closes in September 2027. If you expect to change frameworks, or serve the same agent to web, mobile and Slack, AG-UI is the default to evaluate first.
Sources
- ag-ui-protocol/ag-ui on GitHub: README, stars, license, issues, releases
- AG-UI 1.0 specification
- AG-UI 1.0 Key Changes
- Migrating to 1.0
- Interrupts concept doc
- HTTP + SSE transport binding
- DEPRECATIONS.md
- Python SDK changelog
- ag-ui-protocol on PyPI
- @ag-ui/client on npm
- CopilotKit: Introducing AG-UI 1.0
- AG-UI Dojo
- r/AI_Agents: Google, Microsoft, and AWS all support AG-UI now
- r/AI_Agents: Agents can interact with UI
- r/LangChain: generative UI approaches