Free Intensive Nov 21–22Free 2-day hands-on Vibecoding Intensive on Nov 21–22 at 16:00 MSK (Sat–Sun) · Live Cohort 3 starts Nov 23Join Free →Cohort 3 (Nov 23)
ReleaseCode / SDK · ActionableGitHub Trending AI→ original

AG-UI 1.0 gives AI agents a common language for talking to apps: 31 event types

Every agent framework tells an app in its own way that the agent is typing, has called a tool, or is waiting for human confirmation. The AG-UI 1.0 protocol replaces this custom plumbing with a shared event stream that includes events like "started typing" or "tool called." There are 31 such event types, grouped into eight families. As a result, one agent can run on the web, in a mobile app, or in Slack without rewriting the interface.

AI-processed from GitHub Trending AI; edited by Hamidun News
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceGitHub Trending AI ↗
Editor-in-Chief
Version 1.0 is frozen0.x agents work with 1.0 clients and vice versa
Key metric #2SDKs for TypeScript, Python, and .NET are generated from JSON Schema
Key metric #3Google, Microsoft, Amazon, and Oracle are listed as supporters

Imagine you are embedding an AI agent into a chat inside your product. The agent types its reply word by word, calls a tool in the middle of the reply, for example a database search, and then waits for the user to click "Confirm." Every agent framework reports all of this to the app in its own format, so front-end developers have to write separate plumbing for each backend. The AG-UI protocol (Agent-User Interaction Protocol) removes that plumbing. Version 1.0 defines 31 event types: "agent started typing," "tool called," "state updated," and so on. Any user interface (UI) can display these events.

How it works

A single bidirectional event stream runs between the agent and the app. The app starts a "run" and sends the agent one message containing the conversation history, the list of tools the front end can execute, the shared state, and the context. In response, the agent sends back a stream of typed events. The client does not care what language the agent is written in; it only needs to understand the events.

A everyday analogy is subtitles for a film. A movie can be shot on any camera, but if the subtitle format is standard, any player can show them. Here, the player is a web app, a mobile client, a terminal, or Slack.

The 31 event types are organized into eight families: run lifecycle, text messages, tool calls, state, reasoning, activity, sub-agents, and custom events. Only the first family is mandatory. A minimal agent sends a couple of events, and the rest are added as the product grows.

Through these events flow things that developers usually have to build by hand:

  • streaming messages with cancellation and resumption;
  • a shared state store that both the agent and the app can read and write, synchronized through snapshots and JSON Patch deltas;
  • tools that the agent calls but that are executed in the app, with the result then returned to the agent;
  • human confirmation: the user approves, edits, or rejects an action, and the next run continues from that point;
  • display of the reasoning process, including encrypted reasoning;
  • nested delegation, where each event is tagged with the run of the sub-agent that produced it;
  • images, audio, video, and documents in user input and in tool results.

What "1.0" means for developers

The 1.0 version number signals stability. The specification is frozen and described via JSON Schema, and SDKs for TypeScript, Python, and .NET are generated directly from it. This reduces the risk of client and server diverging in details. Backward compatibility is claimed in both directions: 0.x agents work with 1.0 clients, and vice versa. Teams that have already started integrating will not have to rewrite anything.

The protocol is transport-agnostic: the specification describes an HTTP binding, and middleware can inject events from any other source. Any AG-UI agent is an HTTP endpoint that accepts a request and streams events back. The repository includes an example server and client of about 30 lines. No API keys are needed for it: the server is installed with pip install ag-ui-protocol fastapi uvicorn, and the client with npm install @ag-ui/client tsx (Node.js 20+ required). If you swap the server for another one, the client does not need to change.

For a quick start, there is a CLI: npx create-ag-ui-app@latest generates a Next.js front end or a terminal client for the chosen agent framework. The templates call OpenAI, so an API key is required before running them.

Place among other protocols, and caveats

AG-UI is positioned as the third element in the set of open agent protocols. MCP gives an agent tools and context, A2A lets agents talk to each other, and AG-UI connects the agent to the user. One agent can use all three at once, and AG-UI can sit in front of agents that speak MCP or A2A. Separately, formats such as MCP Apps and Open-JSON-UI describe what interface an agent wants to show. In this scheme, AG-UI is the channel through which those descriptions and everything else reach the app.

The authors state that Google, Microsoft, Amazon, and Oracle have adopted the protocol and that it is built into most agent frameworks. Among the integrations mentioned are OpenAI Agents, watsonx, Spring AI, and clients for React, Angular, Vue, and React Native. These figures come from the project's own description; the material contains no independent verification of the scale of adoption. It is worth looking at the concrete demos in Dojo and checking how well the framework you need is supported without custom workarounds.

Practical takeaway: if you are building a product with multiple interfaces or want to change agent frameworks without rewriting the front end, AG-UI is worth trying on a small prototype. It removes the custom protocol between the agent and the UI that teams usually have to maintain themselves.

Story

Key Questions Answered

How it works?

A single bidirectional event stream runs between the agent and the app. The app starts a "run" and sends the agent one message containing the conversation history, the list of tools the front end can execute, the shared state, and the context. In response, the agent sends back a stream of typed events. The client does not care what language the agent is written in; it only needs to understand the events. A everyday analogy is subtitles for a film.

What "1.0" means for developers?

The 1.0 version number signals stability. The specification is frozen and described via JSON Schema, and SDKs for TypeScript, Python, and .NET are generated directly from it. This reduces the risk of client and server diverging in details. Backward compatibility is claimed in both directions: 0.x agents work with 1.0 clients, and vice versa. Teams that have already started integrating will not have to rewrite anything.

What are the key details on Place among other protocols, and caveats?

AG-UI is positioned as the third element in the set of open agent protocols. MCP gives an agent tools and context, A2A lets agents talk to each other, and AG-UI connects the agent to the user. One agent can use all three at once, and AG-UI can sit in front of agents that speak MCP or A2A. Separately, formats such as MCP Apps and Open-JSON-UI describe what interface an agent wants to show. In this scheme, AG-UI is the channel through which those descriptions and everything else reach the app.

ZK
Zhemal Khamidun — CPO at Alpina Digital, product manager of AlpinaGPT. Building AI products since 2019. Hamidun News is a pet project that grew into a production aggregator with 6,000+ readers.
✦ Unified AI Workspace · Nomad

Test Frontier LLMs & Autonomous Agents in One Workspace

Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.

Try Nomad AI →Launch Nomad Agent
What do you think?
Loading comments…