If you have built anything with AI agents this year, you have met two protocols whether you named them or not. MCP connects an agent to tools and data. A2A lets one agent hand work to another. Both solved a real mess — every integration used to be bespoke — and both stop at the same place: the moment the agent has to show something to a person.
That last hop, agent to screen, is the one every team still wires by hand. This week a third protocol trended on GitHub for trying to standardise it: AG-UI, the Agent-User Interaction Protocol. Its repo now reads "AG-UI 1.0 is here," and for once the thing being announced is aimed squarely at the person writing the React, not the person writing the model calls. So it is worth understanding exactly what it does.
What AG-UI actually is
AG-UI describes itself as "an open, lightweight, event-based protocol that standardises how AI agents connect to user-facing applications." The framing the project uses is that there are three complementary agentic protocols, each owning one edge of an agent: MCP gives agents tools and context, A2A lets agents coordinate with other agents, and AG-UI brings agents to users. A single agent often speaks all three at once.
The reason the UI edge needs its own protocol is that a running agent does more than return text. It streams tokens as it thinks, calls tools in the middle of a response, mutates some shared state, pauses to ask a human, and spawns subagents. Each framework used to surface those moments its own way, so a front end had to learn a bespoke dialect for every backend it talked to. If you have ever written the SSE-parsing glue that turns one vendor's event stream into a chat UI, you know the shape of the problem — and you know it breaks the day you swap backends.
How it works
Mechanically, AG-UI is refreshingly small. An AG-UI agent is any HTTP endpoint
that accepts a RunAgentInput and streams events back. The spec defines an
HTTP + Server-Sent-Events binding and a binary HTTP + Protobuf binding, and the
protocol is otherwise transport-agnostic — the events are the contract, not the
wire.
Those events are where the structure lives. AG-UI 1.0 defines 31 event types grouped into eight families: runs and steps, text messages, tool calls, state, reasoning, activity, subagents, and passthrough. Only the run-lifecycle events are actually required, so a minimal agent can emit a handful — start, some text, finish — and a richer one opts into the rest. That "required core, optional surface" design is the part that makes adoption plausible: you are not forced to implement 31 events to be compliant.
A couple of the families are worth calling out for anyone building the UI side.
Text-message events like RUN_STARTED and TEXT_MESSAGE_CONTENT let the
interface show "thinking", streaming text, and completion without guessing from
raw tokens. The state family is the clever one: STATE_DELTA carries state as a
JSON Patch, so the front end applies a diff to what it already has rather than
re-fetching the whole object on every change. That is the difference between a UI
that flickers through full reloads and one that updates in place.
Why a frontend developer should care
The pitch is not "learn a spec." It is "stop writing the glue." On the client
side, CopilotKit ships AG-UI clients for React, Angular, Vue and React Native, so
the front-end developer adopts a client library instead of hand-parsing SSE for
each backend. On the agent side, the protocol has official SDKs in three
languages — TypeScript (@ag-ui/client), Python (ag-ui-protocol) and .NET
(AGUI.Client) — plus community SDKs for Kotlin, Go, Java, Dart, Rust, Ruby,
C++ and Swift. Getting started wants Python 3.9+ on the agent and Node.js 20+ on
the client.
The adoption signal is real enough to notice: the repository sits at 20.4k stars
with 5,505 commits on main, and the project lists a long roster of agent
frameworks — LangGraph, CrewAI, Mastra, Pydantic AI, the Microsoft Agent
Framework, Google ADK and more — as speaking it. For a developer whose job is the
interface, the value is leverage: write your rendering against one event stream,
and in principle any compliant backend drops in behind it.
What is not settled yet
Two honest caveats. First, the dates are muddier than the "1.0 is here" banner suggests. The project's own changelog lists only the 2025-04-09 public release — "Initial release of the Agent User Interaction Protocol" — and carries no dated 1.0 entry, while secondary write-ups disagree on exactly when 1.0 landed. So treat the version as real and the precise release date as unconfirmed by a primary source.
Second, a protocol is only as good as its implementations. Whether the full 31-event surface actually converges across frameworks in practice — or whether each backend ships a different optional subset and the "write once" promise leaks — is not visible from the spec alone. And there is no published, independent benchmark of the Protobuf binding against plain SSE, so the binary path is a claim, not yet a measured win.
Amar's take
This is my own view. Of the three agent protocols, AG-UI is the one I would actually reach for first, because it lands on the layer I work in. I build with React, Next.js and MCP, and MCP never touched the screen — it gave the agent tools and left me to invent how the result reached the user. Every AI feature I have shipped has needed some version of that glue, and the glue is exactly the code that rots when a vendor changes its stream.
What sells me is not the event count — it is STATE_DELTA as a JSON Patch and
the "only the run lifecycle is required" rule. Those are two decisions made by
someone who has written a front end, not just a spec. A diff-based state channel
is how you build a UI that feels alive instead of one that reloads, and a small
required core is how a standard survives contact with real codebases. I would not
rewrite anything working to adopt it today — the unconfirmed 1.0 date and the
untested cross-framework claims are reason enough to wait a beat. But the next
time I wire an agent to a screen from scratch, this is the pattern I would start
from instead of a hand-rolled SSE parser. The interface layer finally having a
protocol of its own is overdue, and I am glad it is the frontend developer, for
once, who gets the standard built for them.