Search tools, AI agents, MCP servers
Submit a tool

Search iThub

Search tools, categories and collections. Type at least two characters.

Explore all tools
↑ ↓ to explore resultsEnter to open · Esc to close

AG-UI

Open event-based protocol that connects AI agent backends to user-facing applications

Agent FrameworksOpen sourcerelease/2026-11-13

AG-UI at a glance

Pricing
Open source
License
Open source
Version
release/2026-11-13November 13, 2026
Language
TypeScript
Data location
Protocol and SDKs run inside the developer's own agent backend and frontend; AG-UI defines no hosted service, and hosted options named in the docs are separate products.
Maker
ag-ui-protocol
Founded
2025

What is AG-UI?

AG-UI, the Agent-User Interaction Protocol, is an open, event-based protocol that defines how an AI agent backend communicates with a user-facing application. An application sends one input message, RunAgentInput, and the agent answers with an ordered stream of typed events that carry text, tool calls, reasoning, shared state and progress. The official overview places AG-UI beside MCP (agent to tools and data) and A2A (agent to agent) as the agent to user layer of the agentic protocol stack.

The project lives in the ag-ui-protocol organization on GitHub. According to the README and the docs, AG-UI grew out of CopilotKit's initial partnership with LangChain and CrewAI, and CopilotKit is listed as a first-party client; the community links in the README (Discord, X account, biweekly working group calendar) point to CopilotKit channels. The repository holds the specification and documentation source, the TypeScript and Python SDKs, a .NET SDK, community SDKs for other languages, framework integrations, middleware packages and the AG-UI Dojo demo application.

Version 1.0 is the first release with a written specification. The 1.0 specification states that a JSON Schema is authoritative for structure and the specification text is authoritative for behaviour (ordering, lifecycle, error handling, compatibility), written in BCP 14 MUST and SHOULD language. It groups 31 event types into eight families and adds run outcomes with interrupts, subagent events, activity events, a reasoning family that replaces the older THINKING events, and an HTTP plus Protobuf binding. A 1.1 draft is published next to it. The migration guide says 0.x agents keep working against 1.0 clients through a compatibility boundary in the TypeScript client, with provisional expiry dates for those shims.

Packages are published per language and per integration. On the public registries, @ag-ui/core on npm is at 1.0.4 and ag-ui-protocol on PyPI is at 1.0.0. GitHub releases are named by date and list the packages each one publishes. The latest, release/2026-11-13, shipped @ag-ui/langgraph 0.0.46, which reads LangGraph's native interrupt response schema, declares protocolVersion on RUN_STARTED and now requires @ag-ui/client 1.0 or later.

AG-UI is MIT licensed. It is not an agent framework and not a UI component library: it defines the contract between the two. The specification leaves authentication and authorization to the transport and the application, and hosted services named in the docs, such as CopilotKit Intelligence or Amazon Bedrock AgentCore, are separate products rather than part of the protocol. Related listings on iThub include OpenBot by CopilotKit, which the docs list as an AG-UI client, and the generative UI framework OpenUI.

Key capabilities

  • Typed event model The 1.0 specification enumerates 31 event types in eight families: runs and steps, text messages, tool calls, reasoning, state, activity, subagents and passthrough. Only the run lifecycle is mandatory for a producer; a consumer must accept every family, even ones it does not use. The event streams reference lists which part of the client each family is addressed to.
  • Run lifecycle and outcomes RUN_STARTED, RUN_FINISHED and RUN_ERROR frame a run, while STEP_STARTED and STEP_FINISHED mark its phases. In 1.0, RUN_FINISHED carries an optional outcome (success, interrupt or cancelled), and a 1.0 producer must declare its protocol version on RUN_STARTED. A stream that ends without a terminal event is defined as a truncated run, which a consumer must not report as successful.
  • Streaming text messages Assistant output arrives as TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT and TEXT_MESSAGE_END, or in a chunked form. The specification sets rules for chunks: the first chunk must carry the message id and role semantics, later chunks may omit them, and a conflicting value in a continuation is fatal.
  • Tool calls and frontend tools Tool calls stream as TOOL_CALL_START, TOOL_CALL_ARGS, TOOL_CALL_END and TOOL_CALL_RESULT. Tools can be defined by the frontend and passed to the agent in the run input, so the application executes them and returns results. Since 1.0 a tool result can be a string or an ordered list of content parts such as text, images or documents.
  • Shared state STATE_SNAPSHOT sends the complete state, STATE_DELTA sends incremental changes as JSON Patch (RFC 6902) and MESSAGES_SNAPSHOT sends the conversation history. The state management guide describes this as a store shared between agent and application.
  • Interrupts for human-in-the-loop A run can end with an interrupt outcome that lists what it is waiting for. The client then starts a new run on the same thread with resume entries that reference each interrupt id. Core reason values are tool_call, input_required and confirmation; any other string is a valid custom reason.
  • Reasoning events The REASONING_* family streams reasoning spans and messages, and REASONING_ENCRYPTED_VALUE carries provider artefacts that a consumer stores and returns without reading. The five 0.x THINKING_* events are deprecated and translated by the TypeScript client's compatibility layer.
  • Activity, subagents and passthrough events ACTIVITY_SNAPSHOT and ACTIVITY_DELTA carry structured progress that a UI renders outside the transcript. SUBAGENT_STARTED, SUBAGENT_FINISHED and SUBAGENT_ERROR, plus a subagentRunId field, attribute delegated work. RAW and CUSTOM events cover data the protocol does not model.
  • Transports The specification defines two HTTP bindings: HTTP with Server-Sent Events carrying JSON, which any HTTP implementation must support, and an optional HTTP plus Protobuf binding with 4-byte length-prefixed frames selected by content negotiation. Custom transports such as WebSockets or message buses are allowed if they meet the binding contract. AG-UI itself defines no credential.
  • Capability discovery Agents can implement an optional getCapabilities() method that returns a typed declaration covering identity, transport, tools, output, state, multi-agent, reasoning, multimodal input, execution and human-in-the-loop support. The docs state that declarations are informative and the event stream is authoritative; a plain HttpAgent does not implement discovery.
  • Middleware The client SDK accepts function-based and class-based middleware that transforms or filters the event stream before it reaches the application. The built-in FilterToolCallsMiddleware filters emitted tool call events by allow or deny lists; the docs note that it does not block tool execution in the upstream runtime.
  • Serialization and branching The serialization guide describes storing the event history to restore chat and UI state after reloads, compacting streams (merging text chunks, collapsing state deltas into a snapshot) and branching from an earlier run with parentRunId, which forms an append-only lineage.
  • TypeScript SDK @ag-ui/core holds the types and events, and @ag-ui/client provides AbstractAgent, the HttpAgent client for any endpoint that accepts a POSTed RunAgentInput and streams events, middleware and compaction utilities. Encoder and protobuf packages handle the wire formats. In 1.0, zod is an optional peer dependency of @ag-ui/core.
  • Python SDK pip install ag-ui-protocol installs the ag_ui.core types and events and an encoder for emitting event streams from a Python server. Since 1.0 the models are generated from the schema, and absent fields are omitted rather than sent as null.
  • .NET SDK AGUI.Abstractions targets net10.0, net9.0, net8.0, netstandard2.0 and net472 and is AOT-compatible; AGUI.Server targets net10.0, net9.0 and net8.0 and provides hosting endpoints. A chat client package is documented alongside them.
  • Community SDKs The integrations page lists supported community SDKs for Kotlin, Go, Dart, Java, Rust, Ruby and C++, with Nim in progress. The Kotlin SDK documents JVM support on Java 11 or later; the Java SDK requires Java 17 or later, has a dependency-free core and ships Spring WebFlux, Spring WebMVC and Spring AI integrations.
  • Framework integrations The docs list partnership integrations for LangChain (LangGraph) and CrewAI and first-party integrations for Microsoft Agent Framework, Google ADK (Python and JavaScript), Google Antigravity, AWS Strands Agents, Amazon Bedrock AgentCore, Mastra, Pydantic AI, Agno, LlamaIndex and AG2, with AWS Bedrock Agents in progress. Community integrations cover the Claude Agent SDK, Claude Managed Agents, Langroid, Omnara, OpenAI Agents SDK and Cloudflare Agents.
  • AG-UI Dojo The Dojo is a demo viewer with short examples per feature (agentic chat, human in the loop, agentic and tool-based generative UI, shared state, predictive state updates, reasoning) for each integration, with preview, code and docs tabs. Its source is in apps/dojo in the repository.
  • Project scaffolding npx create-ag-ui-app@latest creates a new application with a chosen client and server. For the CopilotKit example, the quickstart starts the app with npm run dev on localhost port 3000.

Where AG-UI fits

Connecting an existing agent framework to a frontend

When an agent is already built with a supported framework, the integration package for that framework translates its native events into AG-UI events. The integrations page links each framework to its docs and Dojo demo, for example LangGraph with FastAPI, CrewAI flows, Mastra or Pydantic AI. Framework listings on iThub include LangChain, CrewAI, LlamaIndex and Agno. The frontend side is any AG-UI client, with CopilotKit listed as the first-party web client.

Writing a server that emits AG-UI events directly

For agents without a framework integration, the server quickstart builds a standalone HTTP server that accepts AG-UI requests, calls an OpenAI model and streams the response back as events, including tool calls and state. It requires Python 3.12 or later, Poetry and an OpenAI API key, starts from the server-starter template in the repository and registers the new server in the Dojo for testing.

Building a client outside the browser

The docs state that an AG-UI client does not have to be a web application, because the protocol describes an event stream rather than a rendering target. The client quickstart builds an interactive terminal chat with @ag-ui/client, @ag-ui/core and @ag-ui/mastra, a weather tool and a browser tool, using Node.js 22.13.0 or later and pnpm. Listed client examples also include React Native and chat platforms such as Slack and Microsoft Teams through CopilotKit's Channels SDK.

Approval steps before sensitive actions

The interrupt model lets an agent stop before a tool runs and ask the user. The run ends with an interrupt outcome bound to a tool call, the UI shows the pending action, and the client resumes with an approval, a rejection or edited arguments. The interrupts guide covers parallel interrupts, approve with edits, non-tool input requests and how state is handled at the interrupt boundary.

Collaborative state between agent and application

Shared state lets the agent and the UI work on the same document or form. The Dojo recipe example is described as a recipe copilot that reads and updates a form collaboratively, covering ingredients, dietary preferences and instructions. On the protocol side, the agent sends a STATE_SNAPSHOT and then STATE_DELTA events as JSON Patch. The Dojo also includes a predictive state updates demo for editing a document in real time with the agent.

Restoring and branching sessions

Because a session is a stream of events, an application can persist that stream and replay it to restore chat history and UI state after a reload, or attach to a running agent. Compaction reduces stored history to snapshots, and setting parentRunId on a new run branches the conversation from any earlier run. These patterns are described in the serialization concept page and the 1.0 specification's snapshot and streaming patterns.

Install

npx create-ag-ui-app@latest

Reviews of AG-UI

No reviews yet

Be the first to share your experience with AG-UI.

Loading review form…

Found AG-UI useful? Upvote it todayYour vote helps other IT teams find it in the daily ranking.

Similar to AG-UI

Compare:AG-UI vs Agent ZeroAG-UI vs CrewAIAG-UI vs LangChain

  1. Agent ZeroOpen-source AI agent framework with its own Linux workspaceAgent Frameworks8 views
  2. CrewAIMIT-licensed Python framework for role-based agent crews and event-driven flows, with the CrewAI AMP platformAgent Frameworks30 views
  3. LangChainOpen-source framework for LLM agents, with LangGraph and LangSmithAgent Frameworks30 views
  4. LlamaIndexOpen-source agent framework and LlamaParse document parsingAgent Frameworks21 views
  5. Hermes AgentSelf-hosted AI agent by Nous Research with persistent memory, self-written skills, cron jobs and chat gatewaysAgent Frameworks10 views
  6. borg (Rust agent runtime)Supervised Rust runtime that runs LLM agent pipelines with cancellation, panic isolation, budgets and checkpointsAgent Frameworks7 views
  7. LobeHubAgent workspace that puts AI agents into team chats, tracks their tasks and runs cloud or self-hostedAgent Frameworks5 views
  8. OmnigentApache-2.0 meta-harness that runs Claude Code, Codex, Pi and other agents with shared sessions, policies and sandboxesAgent Frameworks5 views