← Back to research
·11 min read·opensource

AG-UI

AG-UI is CopilotKit's open, MIT-licensed event-streaming protocol for the agent-to-user layer — ~16 standard event types that connect agent backends to frontends. 14.2K GitHub stars, first-party integrations in Microsoft Agent Framework, Google ADK, AWS Strands, and Amazon Bedrock AgentCore, and a $27M-funded company behind it.

https://ag-ui.com ↗
agent-frameworksagent-infrastructureopen-sourcemcpawstypescript

Key takeaways

  • AG-UI has become the default candidate for the third leg of the agent protocol stack — MCP for tools, A2A for agent-to-agent, AG-UI for agent-to-user — with first-party integrations in Microsoft Agent Framework, Google ADK, AWS Strands Agents, and Amazon Bedrock AgentCore
  • It is an event-streaming protocol: roughly 16 standard event types over SSE, WebSockets, or webhooks handle streaming chat, bi-directional state sync, generative UI, frontend tool calls, and human-in-the-loop
  • The steward is a venture-backed startup, not a foundation — CopilotKit raised a $27M Series A in May 2026 and sells a commercial frontend stack on top of the open protocol, a structure that draws lock-in criticism
  • 14.2K GitHub stars and 1.3K forks as of June 2026, with releases shipping days apart and a bi-weekly public working group

FAQ

What is AG-UI?

AG-UI (Agent-User Interaction Protocol) is an open, lightweight, event-based protocol created by CopilotKit that standardizes how AI agent backends stream their activity — messages, tool calls, state updates, UI — to user-facing applications.

How much does AG-UI cost?

The protocol and SDKs are free and MIT-licensed. CopilotKit, the company behind it, monetizes separately through its commercial frontend stack and enterprise products.

How does AG-UI relate to MCP and A2A?

They are positioned as complementary layers of one stack — MCP gives agents tools, A2A lets agents talk to other agents, and AG-UI brings agents into user-facing applications. AG-UI is agent-to-user, not agent-to-agent.

How is AG-UI different from Google's A2UI?

A2UI is Google's protocol for agent-driven UI rendering, launched with AG-UI as a partner; AG-UI is a separate CopilotKit project covering the broader agent-frontend event stream (chat, state, tools), not just UI generation.

Executive Summary

AG-UI (Agent-User Interaction Protocol) is an open, MIT-licensed, event-based protocol that standardizes how AI agents connect to user-facing applications: an agent backend emits a stream of roughly 16 standard event types — messages, tool calls, state patches, lifecycle signals — and any compliant frontend can render the session in real time over SSE, WebSockets, or webhooks.[1][2] Its pitch is positional: MCP gives agents tools, A2A gives agents other agents, and AG-UI gives agents users — the third leg of the emerging agent protocol stack.[1][3] The framing matters: this is an agent-to-user protocol, not an agent-to-agent one, and it competes for the frontend layer rather than the coordination layer.

Created by CopilotKit out of its experience building in-app agent interactions, AG-UI has accumulated 14.2K GitHub stars and 1.3K forks since its May 2025 repo creation, with first-party integrations in Microsoft Agent Framework, Google ADK, AWS Strands Agents, and Amazon Bedrock AgentCore, plus partnership integrations with LangGraph and CrewAI.[2] Amazon Bedrock AgentCore Runtime added native AG-UI support in March 2026, alongside its existing MCP and A2A support.[3] CopilotKit itself — a Seattle-based company of roughly 25 people — closed a $27M Series A in May 2026 (Glilot Capital, NFX, SignalFire, 97212 Ventures) largely on the strength of AG-UI adoption.[4][5][6]

AttributeValue
CreatorCopilotKit (Seattle; founders Atai Barkai, CEO, and Uli Barkai)[4]
Protocol launchedRepo created May 2025[2]
Company funding$27M total — $20.5M Series A (May 2026) + $6.5M seed; Glilot Capital, NFX, SignalFire, 97212 Ventures[5][4]
GitHub Stars14.2K stars, 1.3K forks as of June 2026[2]
LicenseMIT[2]
Latest releaseJune 9, 2026 (date-tagged releases shipping days apart)[2]

Product Overview

AG-UI defines the contract between an agent backend and a frontend. The agent emits typed events as it runs; the frontend consumes the stream and stays synchronized — no polling, no bespoke glue per framework.[1] The protocol covers real-time streaming chat, bi-directional state synchronization, generative UI, frontend tool integration (the agent can call tools that live in the browser), and human-in-the-loop collaboration, with a middleware layer that abstracts the transport.[1][7] Developers pick an agent framework; AG-UI handles the interaction layer.[3]

Key Capabilities

CapabilityDescription
Event-streaming core~16 standard event types over SSE, WebSockets, or webhooks[1]
Bi-directional state syncShared state between agent and app, patched incrementally[1]
Generative UIAgents return interactive, app-defined UI components, not just text[7][4]
Frontend toolsAgents invoke tools that execute in the user's browser context[1]
Human-in-the-loopApproval and collaboration events as first-class protocol citizens[1]

Framework Integrations

TierFrameworks
First-partyMicrosoft Agent Framework, Google ADK, AWS Strands Agents, Amazon Bedrock AgentCore[2]
PartnershipLangGraph, CrewAI[2]
CommunityClaude Agent SDK, Pydantic AI, Mastra, Agno, LlamaIndex, AG2, Langroid, Oracle Agent Spec[2]
In progressOpenAI Agent SDK, AWS Bedrock Agents, Cloudflare Agents[2]

Technical Architecture

AG-UI is transport-agnostic by design: the specification defines the event vocabulary, and a middleware layer maps it onto SSE, WebSockets, or webhooks, so existing agent backends can adopt it without rearchitecting.[1] The reference implementation is TypeScript-first, with SDKs in Kotlin, Go, Dart, Java, Rust, Ruby, and C++, and .NET in progress.[2] On AWS, Bedrock AgentCore Runtime runs AG-UI servers as containers (HTTP/SSE or WebSocket endpoints) and supplies authentication, session isolation, and scaling around the protocol.[3]

Key Technical Details

AspectDetail
DeploymentProtocol + SDKs; self-host anywhere or run on managed runtimes like Bedrock AgentCore[3]
TransportsSSE, WebSockets, webhooks via middleware layer[1]
SDKsTypeScript reference plus Kotlin, Go, Dart, Java, Rust, Ruby, C++; .NET in progress[2]
GovernanceCopilotKit-stewarded with a bi-weekly public working group; no foundation home[2]
Open SourceMIT license, monorepo on GitHub[2]

Strengths

  • First-party cloud-vendor adoption is the moat — Microsoft Agent Framework, Google ADK, AWS Strands, and Amazon Bedrock AgentCore ship AG-UI integrations themselves, and AWS added runtime-level support in March 2026; protocols live or die on exactly this kind of distribution.[2][3]
  • Clean position in the protocol stack — by claiming the agent-to-user layer that MCP and A2A explicitly do not cover, AG-UI competes with bespoke glue code rather than with entrenched standards.[1][3]
  • Framework-agnostic by construction — fourteen-plus framework integrations across three tiers mean teams can swap agent backends without rewriting the frontend contract.[2]
  • A funded, motivated steward — CopilotKit's $27M raise was premised on AG-UI becoming the standard, and the cadence shows it: date-tagged releases days apart and a bi-weekly working group.[4][2]
  • Enterprise proof points via CopilotKit — Fortune 500 usage with named customers including Deutsche Telekom, Docusign, Cisco, and S&P Global, and millions of weekly installs claimed across the stack.[4][5]

Cautions

  • Single-vendor governance — unlike A2A (Linux Foundation) and MCP, AG-UI has no neutral foundation home; the spec is stewarded by a venture-backed startup whose business depends on it, which is both an incentive and a conflict.[2][4]
  • The protocol-to-product line blurs — the protocol is MIT, but the polished path runs through CopilotKit's commercial stack, and developers have flagged this as soft lock-in.[8]
  • Self-hosting friction in the reference path — CopilotKit's runtime historically required a JS proxy backend holding chat state, a pain point for scalable self-hosting called out by practitioners.[8]
  • Contested layer — Google's A2UI launched in December 2025 with AG-UI as a launch partner, and OpenAI ships ChatKit/Apps SDK; the agent-frontend layer has more would-be standards than the tool or agent-to-agent layers did.[9][8]
  • Adoption numbers are vendor-reported — the "millions of installs weekly" and Fortune 500 claims come from CopilotKit and its funding coverage, not independent measurement.[4][5]

What Developers Say

Community discussion clusters in two HN threads — OpenAI's ChatKit launch and Google's A2UI launch — where AG-UI is the incumbent comparison point. Sentiment splits between respect for the positioning and wariness about the steward:

"But even with AG-UI, CopilotKit is a paid service. Everyone's trying to do vendor lock in, it's really annoying." — peab on Hacker News[8]

"CopilotKit needs a JS backend for a proxy that holds the state for the chat which is quite a pain if you want to scalably self-host." — lukax on Hacker News[8]

"I think AG UI is great if you are building the UI and the Agent at the same time" — zeroasterisk (Google) on Hacker News[9]

"AG-UI is a launch partner of A2UI, but it is a separate project by CopilotKit, not google." — swiftlyTyped, AG-UI author, on Hacker News[9]

"Why on earth would you trust an LLM to output a UI? You're asking for security bugs" — lowsong on Hacker News, on agent-driven UI generally[9]

Pricing & Licensing

TierPriceIncludes
AG-UI protocol + SDKsFreeMIT-licensed spec, event types, all language SDKs, framework integrations[2]
CopilotKit open sourceFreeMIT frontend framework implementing AG-UI (React, Angular, mobile, Slack)[8][6]
CopilotKit EnterpriseCustomCommercial enterprise product ("Enterprise Intelligence") sold to Fortune 500 customers[5]

Licensing model: The protocol and SDKs are MIT; CopilotKit monetizes the layer above it with hosted services and an enterprise product.[2][5]

Hidden costs: None at the protocol level, but the best-documented implementation path is CopilotKit's stack, where managed services (e.g., chat-history hosting) are paid — the lock-in concern developers raise.[8]

Competitive Positioning

AG-UI sits in the agent protocol stack alongside coordination protocols rather than against them: it is the agent-to-user layer, complementary to Google A2A (agent-to-agent) and MCP (agent-to-tools).[3] Its actual competitors are other agent-frontend contracts.

Direct Competitors

CompetitorDifferentiation
Google A2UIGoogle's protocol for agent-driven UI rendering, launched Dec 2025 with AG-UI as a launch partner; narrower (UI generation) where AG-UI covers the full interaction event stream[9]
OpenAI ChatKit / Apps SDKOpenAI's embeddable chat and app surfaces; vertically integrated with OpenAI rather than framework-agnostic[8]
Agent Client ProtocolZed-initiated protocol for connecting coding agents to editors/clients — same agent-to-client instinct, scoped to dev tools rather than end-user apps
assistant-uiMIT chat frontend with no proprietary proxy service; a library rather than a protocol, and it has implemented AG-UI itself[8]
Google A2ANot a competitor — agent-to-agent coordination; the stack framing pairs them[3]

When to Choose AG-UI Over Alternatives

  • Choose AG-UI when: you are building a user-facing agent app and want a framework-agnostic frontend contract with first-party support across Microsoft, Google, and AWS agent stacks.
  • Choose OpenAI ChatKit when: you are all-in on OpenAI's platform and want its hosted surfaces over an open protocol.
  • Choose Agent Client Protocol when: the "user interface" is a code editor or dev tool, not an application frontend.
  • Skip a protocol entirely when: you have one agent, one frontend, and no plans to swap either — bespoke SSE glue is less abstraction.

Ideal Customer Profile

Best fit:

  • Product teams embedding agents into existing applications who want streaming chat, shared state, and generative UI without inventing an event schema
  • Enterprises standardizing across multiple agent frameworks (LangGraph here, ADK there) behind one frontend contract
  • Teams deploying on Bedrock AgentCore or Microsoft Agent Framework, where AG-UI support is already first-party

Poor fit:

  • Headless or backend-only agent systems with no user-facing surface — A2A and MCP cover that stack
  • Teams that require foundation-neutral governance before betting on a protocol
  • Single-agent, single-frontend apps where a protocol layer is overhead

Viability Assessment

FactorAssessment
Financial HealthStrong steward — CopilotKit raised $27M (May 2026 Series A) explicitly to push AG-UI[4][5]
Market PositionFront-runner for the agent-to-user layer — first-party at Microsoft, Google, and AWS — but the layer itself is contested (A2UI, ChatKit)[2][9]
Innovation PaceHigh — date-tagged releases days apart in June 2026; SDKs across 7+ languages[2]
Community/Ecosystem14.2K stars, 1.3K forks, 14+ framework integrations, bi-weekly working group[2]
Long-term OutlookHinges on whether cloud-vendor distribution outruns Google's A2UI and whether governance moves to neutral ground as MCP and A2A did[9]

The bull case is distribution: no other agent-frontend protocol ships first-party in Microsoft Agent Framework, Google ADK, AWS Strands, and Bedrock AgentCore simultaneously.[2][3] The bear case is structural: every prior protocol that won this kind of position (MCP, A2A) ended up under neutral or foundation governance, and AG-UI remains the asset of a 25-person startup whose revenue model sits directly on top of it.[4][8]

Bottom Line

AG-UI is the most credible claim on the agent-to-user layer of the protocol stack — genuinely open (MIT), genuinely adopted (first-party at three hyperscalers' agent frameworks), and moving fast. It is not an agent coordination protocol: it standardizes how one agent talks to its human, not how agents talk to each other, and it belongs in the stack alongside A2A and MCP rather than in competition with them. The honest risk is governance, not technology — a single venture-backed steward with a commercial stack one layer up.

Recommended for: teams shipping user-facing agent applications across heterogeneous frameworks; anyone already on Bedrock AgentCore, Microsoft Agent Framework, or Google ADK.

Not recommended for: headless agent pipelines; organizations that require foundation governance before standardizing; single-stack apps where the abstraction adds nothing.

Outlook: Watch three things — whether Google's A2UI partnership stays complementary or turns competitive, whether AG-UI follows MCP and A2A into neutral governance, and whether the spec stabilizes from date-tagged releases into versioned, stable contracts.

Research by Ry Walker Research • methodology

Sources

Share on XShare on LinkedIn