How
Agent backends emit AG-UI events (via framework integrations); the frontend renders them. Agents call frontend-registered tools to act on the UI and read/write shared state.
AG-UI + CopilotKit
Event protocol connecting agent backends to app frontends, plus CopilotKit.
ag-ui.com ↗repo ↗docs ↗CopilotKit ↗AG-UI 1.0 release discussion (#2792, 2026-09-18) ↗AG-UI serialization (branching/time travel) ↗Terminal client quickstart ↗CopilotKit Series A (2026-05-05) ↗
- license
- MIT · Both AG-UI and CopilotKit are MIT. AG-UI is led by CopilotKit (company) with a biweekly working group; community SDKs in many languages.
- language
- TypeScript and Python (official SDKs); community Kotlin, Go, Dart, Java, Rust, Ruby, C++, .NET
- backing
- CopilotKit (VC-backed: $27M Series A led by Glilot Capital, NfX, SignalFire, announced 2026-05-05)
- stars
- 16,415 (as of 2026-10-09)
- downloads
- @ag-ui/core 2,417,912/week, @ag-ui/client 1,500,823/week, @copilotkit/react-core 507,497/week, @copilotkit/runtime 427,748/week (npm, week ending 2026-10-07). CopilotKit repo: 37,871 stars.
- latest release
- AG-UI 1.0 spec (frozen); @ag-ui/core 1.0.2; CopilotKit v1.77.2, 2026-10-08
- first release
- 2025-05
complement
AG-UI is a likely input transport for scene, not a competitor to its rendering and control model.
Complement it: it does a neighbouring job; interoperate.
the steelman: the best honest case for it
AG-UI won the plumbing layer. Google ADK, Microsoft Agent Framework, AWS Strands and Bedrock AgentCore, LangGraph, CrewAI, Mastra, Pydantic AI and more emit it, its 1.0 spec is frozen with JSON Schemas, and the npm core moves 2.4M downloads a week. It doesn't pick a UI language; it carries everything an interactive agent session needs (streamed text, tool calls, shared state as snapshots plus RFC 6902 deltas, activities, reasoning, subagents) and can carry A2UI or MCP Apps on top. It even has a principled history story: serialized event streams, compaction, and run branching via parentRunId. CopilotKit then gives app developers shared state, frontend tools and three generative-UI modes out of the box, and is funded to keep doing it.
scores
| UI as data | 2 scene 5 | State and events are JSON; the UI is React/Angular components unless A2UI is layered on. |
|---|---|---|
| Agent can drive it | 3 scene 5 | Agents drive via events, shared state and frontend tools; no generic operate-the-UI channel. |
| Agent can see it | 3 scene 5 | Structured shared state and context, no rendered-view capture. |
| Small, targeted edits | 4 scene 5 | RFC 6902 state deltas. |
| Time travel | 3 scene 0 | Serialized event log with branching runs; agent-level lineage rather than UI seek/replay. |
| Live data rate | 2 scene 5 | |
| Terminal native | 2 scene 5 | A CLI chat client example and community Textual client; nothing like a general terminal renderer. |
| Pixel graphics | 3 scene 4 | Whatever the web app's own components draw; nothing in the protocol. |
| Teaching | 0 scene 3 | |
| Maturity | 4 scene 1 | |
| Openness | 4 scene 4 | MIT, but steered by one VC-backed company. |
AG-UI + CopilotKit scene now scene planned
how agents use it
Wiring it in
Low if your framework already has an AG-UI adapter (most do); CopilotKit provides the frontend components.
Seeing the result
Shared state is bidirectional and frontend context is sent with each run, so the agent sees structured app state; it does not see the rendered view.
Small edits
STATE_DELTA JSON Patch on shared state is cheap and path-addressed; UI changes follow from state, not from addressing components.
History
Event streams are serializable; runs can branch from prior runs (parentRunId) and be compacted. Conversation/run-level, not UI-frame-level.
In short
Strong agent<->app state channel with real history semantics, but it leaves the UI itself to the app.
architecture
AG-UI is a transport-agnostic stream of typed JSON events from agent to frontend (SSE, WebSocket, webhooks): lifecycle (RUN_STARTED/FINISHED/ERROR, STEP_*), text messages, tool calls (START/ARGS/END/RESULT), state (STATE_SNAPSHOT, STATE_DELTA as RFC 6902 JSON Patch, MESSAGES_SNAPSHOT), activity snapshots/deltas, reasoning, subagent, raw and custom events. The frontend sends simple run inputs (messages, state, tools, context). Serialization defines persisting and compacting the event stream and branching runs via parentRunId ('time travel'). CopilotKit is the React/Angular/Vue/React Native client: shared state (useAgent with agent.state/setState), frontend tools the agent can call, human-in-the-loop, and generative UI in three flavours: controlled (AG-UI tool rendering), declarative (A2UI) and open-ended (MCP Apps).
- UI-agnostic: AG-UI carries state and events, not a component tree
- STATE_DELTA = RFC 6902 patches over shared agent state; ACTIVITY_DELTA likewise
- Run lineage via parentRunId; event compaction to snapshots
- Transport binding for A2UI and MCP Apps (AG-UI is listed as an A2UI transport)
- Terminal: docs include a CLI chat client quickstart; Channels SDK targets Slack/Teams; community Textual client 'gentui'
performance
No published latency or throughput numbers for the protocol; adoption figures are company claims.
- CopilotKit libraries reach over 4 million weekly downloads; millions of agent-user interactions per week copilotkit.ai ↗
adoption and upkeep
Adoption
The most widely adopted agent-to-frontend protocol; nearly every major agent framework emits it, and CopilotKit says its libraries exceed 4M weekly downloads (company claim).
Used by: Google ADK, Microsoft Agent Framework, AWS Strands Agents, Amazon Bedrock AgentCore, LangGraph, CrewAI, Mastra, Pydantic AI, Agno, LlamaIndex, AG2, Oracle Agent Spec, Claude Agent SDK (community integration)
Maintainability
Extremely active, funded, with a 1.0 frozen spec as of September 2026.
Releases: AG-UI: date-tagged releases near-daily (2026-10-02, 10-05, 10-06, 10-08, 10-09); CopilotKit: v1.76.0 2026-10-01, v1.77.0 10-02, v1.77.1 10-07, v1.77.2 10-08 · Contributors: AG-UI ~169, CopilotKit ~264 (GitHub contributors API incl. anonymous) · Recent: AG-UI 1,892 and CopilotKit 5,322 commits on main since 2026-07-11 (GitHub API) · Bus factor: medium-high: one company leads, but large contributor base and many framework vendors depend on the protocol
weaknesses
- Not a UI format: generative UI requires CopilotKit components or a second spec (A2UI/MCP Apps)
- Governance is effectively CopilotKit's; adoption claims (Fortune 500 majority, 4M weekly downloads) are company statements
- Web/React-centric; terminal support is a chat-client tutorial, not a renderer
- Agent sees state, never the rendered output
- History is at run/conversation level; no UI-frame seek or replay
and thc-scene
Overlap
Shared state synchronized between agent and UI with JSON Patch deltas; event-sourced sessions; branching history.
What scene would be reinventing
An event vocabulary for agent<->UI sessions and run lineage; scene's socket ops and planned history log overlap with AG-UI's events and serialization.
The gap it leaves
The terminal UI itself: a renderer, keys/mouse, screen readback, high-rate data bypass, pixels, tours. AG-UI moves events; scene is the surface.
What to borrow
- Consume AG-UI event streams so any AG-UI agent (ADK, LangGraph, Mastra...) can drive a scene
- STATE_SNAPSHOT/STATE_DELTA semantics for scene's data model
- parentRunId-style lineage for scene's fork/replay
- Event compaction (collapse deltas into snapshots) for scene history export
sources
- ag-ui-protocol/ag-ui README github.com
- AG-UI events docs.ag-ui.com
- AG-UI serialization docs.ag-ui.com
- AG-UI client quickstart (terminal) docs.ag-ui.com
- AG-UI 1.0 is officially released (#2792) github.com
- CopilotKit Series A copilotkit.ai
- CopilotKit repo github.com
- npm downloads API api.npmjs.org