agenticweb.wiki

Agent-User Interaction Protocol (AG-UI)

Last checked · 38 primary sources

This page is about AG-UI, the Agent-User Interaction Protocol, the open event-based protocol from the CopilotKit team that connects an agent backend to a user-facing application [1][2]. It is not A2UI, the Google-originated open format in which an agent sends a declarative JSON description of a user interface, which AG-UI can carry [1][20]; see A2UI. It is not MCP Apps, the official MCP extension (SEP-1865) in which a server ships pre-built HTML as a ui:// resource rendered in a sandboxed iframe, which the AG-UI integrations page lists as a generative UI integration [21]; see MCP Apps. It is not ACP, the Agent Client Protocol, the open protocol that Zed created so that third-party coding agents can work inside code editors; see Agent Client Protocol.

Overview

The documentation describes AG-UI this way: "AG-UI is an open, lightweight, event-based protocol that standardizes how AI agents connect to user-facing applications." [1]. An application starts a run by sending one request to an agent, and the agent answers with an ordered stream of typed events: the text it is writing, the tools it is calling, its reasoning, changes to state it shares with the application, and its progress [8][10]. Over HTTP this is a POST answered by a Server-Sent Events stream, with an optional binary encoding [11]. Because the events are standard, a frontend built for one agent framework can talk to an agent built with another, and the documentation lists integrations with agent frameworks from many companies and open-source projects, as well as several clients [3][21].

Why it matters for AI agents: MCP connects an agent to tools and A2A connects it to other agents, but neither defines how a running agent talks to the person using an application. AG-UI fills that gap, and its documentation presents the three as complementary [19]. It carries the interaction itself rather than a description of a screen: "Despite the naming similarities, AG-UI is not a generative UI specification — it's a User Interaction protocol that provides the bi-directional runtime connection between the agent and the application." [20]. A user interface described in A2UI, or an interface shipped through MCP Apps, can travel over an AG-UI connection [20][21]. CopilotKit started the protocol and its team remains the default code owner [2][6], but AWS, Google, Microsoft and Oracle have built support into their own agent platforms [23][25][29][33].

Who uses it

Listed only where the product's own live documentation, opened on 2026-10-28, shows AG-UI support.

Not listed: frameworks that appear only in the AG-UI integration tables (for example LangChain, LlamaIndex, Agno and AG2) without their own documentation being opened for this check [3][21]; AWS Bedrock Agents and the OpenAI Agents SDK, which the README marks as in progress [3]; and Oracle's own blog announcements, which returned HTTP 403 to every fetch on 2026-10-28 (Oracle is listed from its documentation instead) [33][34]. No public statement was found from a company running AG-UI in a customer-facing production product other than the platform vendors themselves.

Who reads it

The 1.0 release discussion names outside contributors: "Many individuals and contributors helped shape AG-UI 1.0 during the review period, including people building on AG-UI at Anthropic, Google, Microsoft, Pydantic, and TanStack." [13].

Recent coverage

See also

References

  1. AG-UI documentation, AG-UI Overview (docs.ag-ui.com), checked 2026-10-28: "AG-UI is an open, lightweight, event-based protocol that standardizes how AI agents connect to user-facing applications." "A2UI is a generative UI specification - allowing agents to deliver UI widgets, where AG-UI is the Agent↔User Interaction protocol - which connects an agentic frontend to any agentic backend." — https://docs.ag-ui.com/introduction
  2. Nathan Tarbert, Introducing AG-UI: The Protocol Where Agents Meet Users (CopilotKit blog), 2025-05-12: "By Nathan Tarbert May 12, 2025" "We're thrilled to announce AG-UI, the Agent-User Interaction Protocol, a streamlined bridge connecting AI agents to real-world applications." "AG-UI is an open, lightweight protocol that streams a single JSON event sequence over standard HTTP or an optional binary channel." — https://www.copilotkit.ai/blog/introducing-ag-ui-the-protocol-where-agents-meet-users
  3. ag-ui-protocol/ag-ui, README.md (text checked at the raw.githubusercontent.com copy), checked 2026-10-28: "AG-UI was born from CopilotKit's initial partnership with LangChain and CrewAI - and brings the incredibly popular agent-user-interactivity infrastructure to the wider agentic ecosystem." "1st party = the platforms that have AG‑UI built in and provide documentation for guidance." "Biweekly AG-UI Working Group" — https://github.com/ag-ui-protocol/ag-ui/blob/main/README.md
  4. GitHub API record for ag-ui-protocol/ag-ui (timestamps in UTC), checked 2026-10-28: ""created_at": "2025-05-07T12:49:37Z"" ""spdx_id": "MIT"" ""description": "AG-UI: the Agent-User Interaction Protocol. Bring Agents into Frontend Applications."" — https://api.github.com/repos/ag-ui-protocol/ag-ui
  5. ag-ui-protocol/ag-ui, LICENSE (text checked at the raw.githubusercontent.com copy), checked 2026-10-28: "MIT License Copyright (c) 2025" — https://github.com/ag-ui-protocol/ag-ui/blob/main/LICENSE
  6. ag-ui-protocol/ag-ui, .github/CODEOWNERS (first rule) (text checked at the raw.githubusercontent.com copy), checked 2026-10-28: "* @ag-ui-protocol/copilotkit" — https://github.com/ag-ui-protocol/ag-ui/blob/main/.github/CODEOWNERS
  7. ag-ui-protocol/ag-ui, CONTRIBUTING.md (text checked at the raw.githubusercontent.com copy), checked 2026-10-28: "This step is only needed if you want to be added as a co-owner who can merge changes to your integration without core team review." — https://github.com/ag-ui-protocol/ag-ui/blob/main/CONTRIBUTING.md
  8. AG-UI, Specification (1.0), checked 2026-10-28: "AG-UI is an open protocol that standardizes how agents talk to user-facing applications: one request in, one ordered stream of typed events out, carrying everything the user sees of the agent — text, tool calls, reasoning, shared state, progress." "The schema is authoritative for structure." "This document is authoritative for behaviour." — https://docs.ag-ui.com/spec/1.0/index
  9. AG-UI, Key Changes (what 1.0 changes against 0.x), checked 2026-10-28: "The specification exists. 0.x defined shapes; behaviour lived in the TypeScript client." "events are retired in favour of the reasoning family" — https://docs.ag-ui.com/spec/1.0/changelog
  10. AG-UI, Event Streams (1.0 specification), checked 2026-10-28: "Everything a producer has to say arrives as events, in eight families." "Only the run lifecycle is mandatory for a producer — every other family is a feature it emits when it has something to say with it." — https://docs.ag-ui.com/spec/1.0/events/index
  11. AG-UI, Transports (1.0 specification), checked 2026-10-28: "the run input is an HTTP POST; the events stream back as SSE frames carrying JSON." "the same POST, negotiated to a binary response of length-prefixed protobuf frames." "An implementation that speaks HTTP MUST support the SSE binding; the protobuf binding is OPTIONAL." "Implementations MAY carry AG-UI over other channels — WebSockets, message buses, in-process pipes." "AG-UI defines no credential" — https://docs.ag-ui.com/spec/1.0/basic/transports/index
  12. AG-UI documentation, Migrating to 1.0, checked 2026-10-28: "AG-UI 1.0 is the first release with a specification behind it" — https://docs.ag-ui.com/migrating-to-1-0
  13. Markus Ecker (mme), AG-UI 1.0 is officially released (GitHub Discussion #2792, ag-ui-protocol/ag-ui), 2026-09-18: "Following the draft period and the feedback collected here, AG-UI 1.0 is now officially released and frozen." "The 1.0 specification will remain unchanged, while future protocol evolution will happen through new draft specifications and open community discussion before each release." "Many individuals and contributors helped shape AG-UI 1.0 during the review period, including people building on AG-UI at Anthropic, Google, Microsoft, Pydantic, and TanStack." — https://github.com/ag-ui-protocol/ag-ui/discussions/2792
  14. GitHub API record for Discussion #2792 (timestamps in UTC), checked 2026-10-28: ""created_at": "2026-09-18T15:02:00Z"" — https://api.github.com/repos/ag-ui-protocol/ag-ui/discussions/2792
  15. npm registry record for @ag-ui/core (timestamps in UTC), checked 2026-10-28: ""1.0.0":"2026-09-17T18:27:36.097Z"" ""1.0.3":"2026-10-16T08:40:38.297Z"" ""latest":"1.0.3"" — https://registry.npmjs.org/@ag-ui/core
  16. PyPI JSON record for ag-ui-protocol (timestamps in UTC; the release files shown are for the current version), checked 2026-10-28: ""upload_time":"2025-04-30T11:28:16"" ""version":"1.0.0"" ""upload_time":"2026-09-17T18:31:18"" — https://pypi.org/pypi/ag-ui-protocol/json
  17. GitHub API, releases of ag-ui-protocol/ag-ui (timestamps in UTC), checked 2026-10-28: ""tag_name": "release/2026-10-21"" ""published_at": "2026-10-21T07:06:21Z"" — https://api.github.com/repos/ag-ui-protocol/ag-ui/releases?per_page=100
  18. Anmol Baranwal and Eli Berman, Introducing AG-UI 1.0: a stable spec for connecting any agent to any application (CopilotKit blog), 2026-09-30: "By Anmol Baranwal and Eli Berman September 30, 2026" "The TypeScript, Python and .NET SDKs are now generated from that schema." "AG-UI 1.0 is backwards compatible, so your existing agents and apps keep working." — https://www.copilotkit.ai/blog/ag-ui-1.0
  19. AG-UI documentation, MCP, A2A, and AG-UI, checked 2026-10-28: "Connects agents to tools and to context — but those tools are themselves becoming agentic." "Connects agents to other agents." "These three agentic protocols are complementary and have distinct technical goals; a single agent can and often does use all 3 simultaneously." "AG-UI contributors have recently added handshakes, allowing AG-UI to "front for" agents through MCP and A2A protocols, which allows AG-UI client apps and libraries to seamlessly use MCP and A2A supporting agents." — https://docs.ag-ui.com/agentic-protocols
  20. AG-UI documentation, Generative UI (AG-UI and generative UI specs), checked 2026-10-28: "Despite the naming similarities, AG-UI is not a generative UI specification — it's a User Interaction protocol that provides the bi-directional runtime connection between the agent and the application." "AG-UI natively supports all of the above generative UI specs and allows developers to define their own custom generative UI standards as well." — https://docs.ag-ui.com/concepts/generative-ui-specs
  21. AG-UI documentation, Integrations, checked 2026-10-28: "This page showcases various Agent User Interaction Protocol (AG-UI) integrations that demonstrate the protocol's capabilities and versatility." — https://docs.ag-ui.com/integrations
  22. AG-UI documentation, Build clients, checked 2026-10-28: "For production use, use a full-featured client like CopilotKit." — https://docs.ag-ui.com/quickstart/clients
  23. AWS documentation, Deploy AG-UI servers in AgentCore Runtime (Amazon Bedrock AgentCore Developer Guide), checked 2026-10-28: "Amazon Bedrock AgentCore Runtime lets you deploy and run Agent User Interface (AG-UI) servers in the AgentCore Runtime." "Amazon Bedrock AgentCore handles authentication (SigV4/OAuth 2.0), session isolation, and scaling." — https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-agui.html
  24. AWS What's New, Amazon Bedrock AgentCore Runtime now supports the AG-UI protocol, 2026-03-13: "Posted on: Mar 13, 2026" "Amazon Bedrock AgentCore Runtime now supports the Agent-User Interaction (AG-UI) protocol, enabling developers to deploy AG-UI servers that deliver responsive, real-time agent experiences to user-facing applications." "Where MCP provides agents with tools and A2A enables agent-to-agent communication, AG-UI brings agents into user-facing applications." — https://aws.amazon.com/about-aws/whats-new/2026/03/amazon-bedrock-agentcore-runtime-ag-ui-protocol/
  25. Microsoft Learn, AG-UI Integration with Agent Framework, checked 2026-10-28: "The Agent Framework AG-UI integration provides seamless connectivity between your agents and web clients." — https://learn.microsoft.com/en-us/agent-framework/integrations/by-component/ui/ag-ui/
  26. .NET Team, Announcing .NET 10 (.NET Blog), 2025-11-11: "Announcing .NET 10 November 11th, 2025" "Microsoft Agent Framework now supports the AG-UI protocol for building rich agent user interfaces." — https://devblogs.microsoft.com/dotnet/announcing-dotnet-10/
  27. Daniel Roth, AG-UI Protocol now has a first-class .NET SDK (.NET Blog), 2026-09-25: "AG-UI Protocol now has a first-class .NET SDK September 25th, 2026" "The .NET team is pleased to announce that we've contributed a .NET SDK for AG-UI in collaboration with CopilotKit." "The Microsoft Agent Framework (MAF) AG-UI support for .NET is now based on the AG-UI .NET SDK." — https://devblogs.microsoft.com/dotnet/ag-ui-dotnet-sdk/
  28. Alan Blount, Google, Delight users by combining ADK Agents with Fancy Frontends using AG-UI (Google Developers Blog), 2025-09-26: "SEPT. 26, 2025" "Today, we're excited to highlight a new integration that directly addresses this challenge: the Agent Development Kit (ADK) now works with AG-UI, an open protocol for building rich, interactive AI user experiences." — https://developers.googleblog.com/en/delight-users-by-combining-adk-agents-with-fancy-frontends-using-ag-ui/
  29. Agent Development Kit documentation, AG-UI user interface for ADK, checked 2026-10-28: "AG-UI is an open protocol that handles streaming events, client state, and bi-directional communication between your agents and users." — https://adk.dev/integrations/ag-ui/
  30. Pydantic Docs, Agent-User Interaction (AG-UI) Protocol (Pydantic AI), checked 2026-10-28: "The Agent-User Interaction (AG-UI) Protocol is an open standard introduced by the CopilotKit team that standardises how frontend applications communicate with AI agents, with support for streaming, frontend tools, shared state, and custom events." — https://pydantic.dev/docs/ai/integrations/ui/ag-ui/
  31. CrewAI documentation, Frontend Overview, checked 2026-10-28: "The ag-ui-crewai package exposes any Crew or Flow as an AG-UI endpoint." — https://docs.crewai.com/edge/en/guides/frontend/overview
  32. Mastra Docs, CopilotKit (Agentic UI integrations), checked 2026-10-28: "CopilotKit talks to Mastra through the AG-UI protocol." "The @ag-ui/mastra package exposes your Mastra agents as an AG-UI endpoint" — https://mastra.ai/integrations/agentic-ui/copilotkit
  33. Oracle, How to Use AG-UI with Agent Spec (PyAgentSpec documentation), checked 2026-10-28: "With the Agent Spec x AG-UI integration, you can take a portable Agent Spec configuration (JSON) and interact with it in AG-UI frontends, while keeping your choice of runtime (LangGraph, WayFlow)." — https://oracle.github.io/agent-spec/development/howtoguides/howto_ag_ui.html
  34. Nathan Tarbert and Eli Berman, Oracle adopts AG-UI protocol for Agent Spec (CopilotKit blog), 2025-12-18: "By Nathan Tarbert and Eli Berman December 18, 2025" "Oracle's Open Agent Specification (Agent Spec) and AG-UI (Agent-User Interaction Protocol) now work together to solve that gap." — https://www.copilotkit.ai/blog/oracle-adopts-ag-ui-protocol-for-agent-spec
  35. Roi Dannon, Via, Agent-User Interaction Protocol: When the frontend got an AI protocol (Via resources), 2026-01-07: "Roi Dannon • January 7, 2026" "demonstrated the power of the Agent-User Interaction Protocol (AG-UI) in a successful internal experiment. We built a specialized chatbot assistant for our backoffice rider management system" — https://ridewithvia.com/resources/agent-user-interaction-protocol-when-the-frontend-got-an-ai-protocol
  36. Paul Krill, Microsoft releases .NET SDK for AG-UI agent-user interaction protocol (InfoWorld), 2026-09-27: "Microsoft releases .NET SDK for AG-UI agent-user interaction protocol news Sep 27, 2026" "Microsoft on September 25 announced a .NET SDK for AG-UI (Agent-User Interaction). Created in collaboration with CopilotKit, the new SDK allows C# developers to work with the protocol that standardizes how agents communicate with user-facing applications." "AG-UI is an event-based protocol that allows AI agents to interact with front-end applications." — https://www.infoworld.com/article/4227233/microsoft-releases-net-sdk-for-ag-ui-agent-user-interaction-protocol.html
  37. Emmanuel John, Don't ship another chat UI. Build real AI with AG-UI (LogRocket Blog), 2026-01-06: "The Agent User Interaction (AG UI) Protocol takes a different path by defining a structured, event-driven contract between agents, tools, and UIs." — https://blog.logrocket.com/build-real-ai-with-ag-ui/
  38. Michał Pasierbski, Bridging Agents to UI: How AG-UI and CopilotKit Make It Stupidly Easy (Practically Agents), 2026-02-25: "February 25, 2026" "Connecting an agent backend to a real-time UI used to mean custom SSE handlers, proprietary event schemas, and hand-rolled state sync. AG-UI is an open, event-based protocol that standardizes all of it." — https://practicallyagents.com/articles/the-agent-ui-gap-ag-ui-and-copilotkit/

JSON · Markdown · OKF v0.2