# AG-UI Protocol

> Source: https://aiwiki.ai/wiki/ag_ui_protocol
> Updated: 2026-06-07
> Categories: AI Agents, Developer Tools
> From AI Wiki (https://aiwiki.ai), a free encyclopedia of artificial intelligence. Quote with attribution.

# AG-UI Protocol

The **AG-UI Protocol** (Agent-User Interaction Protocol) is an open, event-based protocol that standardizes how AI agents communicate with user-facing applications. It defines a streaming wire format, typically delivered over Server-Sent Events, that lets an agent backend emit a continuous sequence of typed JSON events (messages, tool calls, state deltas, lifecycle signals) which a frontend consumes in real time.[^1][^2] AG-UI was created by the team at CopilotKit and announced in May 2025 to address the agent-to-user leg of the emerging agent protocol stack, complementing the [Model Context Protocol](/wiki/model_context_protocol) (agent-to-tool) and the [Agent2Agent Protocol](/wiki/a2a_protocol) (agent-to-agent).[^1][^3] The protocol is published under the MIT license at `github.com/ag-ui-protocol/ag-ui` and has been integrated by major framework and cloud vendors including Microsoft, Google, Amazon, Oracle, and a range of open-source agent frameworks such as [LangGraph](/wiki/langgraph), [CrewAI](/wiki/crewai), [Mastra](/wiki/mastra), Pydantic AI, and Agno.[^2][^4][^5]

## Infobox

| Attribute | Value |
| --- | --- |
| Full name | Agent-User Interaction Protocol |
| Short name | AG-UI |
| Creator | CopilotKit (Tawkit, Inc.) |
| CEO / co-founder | Atai Barkai |
| Initial announcement | May 12, 2025 |
| Repository | github.com/ag-ui-protocol/ag-ui |
| License | MIT |
| Transport | HTTP POST + Server-Sent Events (binary and WebSocket optional) |
| Standardized event types | ~16 across 5 categories |
| Reference SDKs | TypeScript, Python; community: Kotlin, Go, Dart, Java, Rust |
| Companion protocols | [MCP](/wiki/model_context_protocol), [A2A](/wiki/a2a_protocol) |
| Series A funding (CopilotKit) | $27M, May 2026 |

## Background

The 2024 to 2026 wave of agentic systems exposed a recurring engineering pain point: connecting a non-deterministic, long-running agent backend to an interactive frontend was almost always handled with bespoke code. Teams reinvented streaming chat layers, tool-call rendering, intermediate "thinking" UI, partial state updates, and human-in-the-loop approval flows for every project, often using different mechanisms (WebSockets, ad hoc SSE encodings, JSON-streaming over HTTP, polling, framework-specific stream formats). The result was tight coupling between the choice of agent framework and the frontend implementation, and a lack of portability between backends such as [LangChain](/wiki/langchain), [LangGraph](/wiki/langgraph), and [CrewAI](/wiki/crewai).[^1][^6]

CopilotKit, an open-source library for building in-app AI copilots, had repeatedly hit this problem while shipping production integrations. Through partnerships with the LangGraph and CrewAI teams, the company began factoring out a shared event vocabulary that both sides of the connection could agree on. That work was released in May 2025 as AG-UI.[^1][^4] The protocol was framed as the third member of a three-protocol agent stack:

- **[Model Context Protocol](/wiki/model_context_protocol) (MCP)**, introduced by [Anthropic](/wiki/anthropic) in November 2024 for agent-to-tool and agent-to-data connectivity, including the standardization of [MCP servers](/wiki/mcp_server).
- **[Agent2Agent Protocol](/wiki/a2a_protocol) (A2A)**, introduced by Google in April 2025 for agent-to-agent communication and task delegation.
- **AG-UI**, introduced by CopilotKit in May 2025 for the agent-to-user UI surface.[^3][^7]

CopilotKit positions the three as complementary layers of a single stack rather than as competing standards. In a typical end-to-end system, a frontend connects to an orchestrator via AG-UI, the orchestrator delegates to specialist agents over A2A, and individual agents fetch data and invoke side effects through MCP servers.[^3][^7]

## History and Timeline

The announcement post "Introducing AG-UI: The Protocol Where Agents Meet Users" was published on the CopilotKit blog and cross-posted on DEV Community on May 12 to 13, 2025, authored by CopilotKit developer-relations engineer Nathan Tarbert.[^1][^6] Initial materials introduced the protocol specification, a reference TypeScript SDK, a Python SDK, the `ag-ui-protocol/ag-ui` GitHub organization, and reference adapters for LangGraph and CrewAI. A dedicated documentation site at `docs.ag-ui.com` was launched alongside the announcement, including an interactive playground and a quickstart based on `npx create-ag-ui-app`.[^1][^2]

Adoption broadened over the following twelve months. By late 2025 the project had added first-party integrations with Microsoft Agent Framework, Google ADK, AWS Strands Agents, Mastra, Pydantic AI, Agno, LlamaIndex, and AG2.[^2][^8] On December 18, 2025, Oracle announced an AG-UI integration for its Open Agent Specification (Agent Spec), enabling Agent Spec JSON configurations to expose AG-UI endpoints across compatible runtimes including LangGraph, WayFlow, and CrewAI.[^5] In May 2026, CopilotKit raised a $27 million Series A funding round (led by Glilot Capital, NFX, and SignalFire) explicitly tied to AG-UI adoption, citing integrations from Google, Microsoft, Amazon, and Oracle as well as enterprise users such as Deutsche Telekom, Docusign, Cisco, and S&P Global.[^9][^10] CopilotKit's CEO Atai Barkai (previously an engineer on media infrastructure at Meta and lead developer for the Doximity iOS app) led the protocol's commercial development.[^9]

By the time of the Series A, the GitHub repository reported roughly 13.7k stars, 1.2k forks, and 86 watchers under the MIT license, with active biweekly working-group meetings.[^2] Microsoft's Agent Framework documentation, published November 7, 2025 and updated in April 2026, advertised support for all seven canonical AG-UI feature areas (agentic chat, backend tool rendering, human-in-the-loop, agentic generative UI, tool-based generative UI, shared state, and predictive state updates) through an `Microsoft.Agents.AI.Hosting.AGUI.AspNetCore` NuGet package and a corresponding `agent-framework-ag-ui` Python package.[^4]

## How It Works

### Connection lifecycle

The canonical interaction model is straightforward. A client (typically a browser, React Native shell, or terminal) sends a single HTTP POST request to an AG-UI endpoint, carrying the user's prompt, any frontend context, and a thread or session identifier. The server responds by holding the connection open and emitting a stream of typed JSON events over Server-Sent Events. Clients can also reconnect, cancel runs, and post back user actions, making the interaction effectively bidirectional even though the streaming channel itself is one-way per request.[^1][^11][^12]

The protocol explicitly does not mandate a transport. SSE is the default because it is firewall-friendly, lightweight, and natively supported by browsers, but the specification also allows a binary serialization for higher throughput, as well as alternative transports such as WebSockets and webhooks. The protocol contract is captured by a function-level abstraction of the form `run(input: RunAgentInput) -> Observable<BaseEvent>`, which an implementation can fulfil over any duplex or streaming channel.[^11]

### Event types

AG-UI defines roughly sixteen standardized event types grouped into five categories. Each event carries a small JSON payload with the minimum data required for the frontend to update the UI incrementally:[^11][^12][^13]

| Category | Events | Purpose |
| --- | --- | --- |
| Lifecycle | `RUN_STARTED`, `RUN_FINISHED`, `RUN_ERROR`, `STEP_STARTED`, `STEP_FINISHED` | Marks the beginning, end, error state, and intermediate steps of an agent execution. |
| Text messages | `TEXT_MESSAGE_START`, `TEXT_MESSAGE_CONTENT`, `TEXT_MESSAGE_END` | Streams generated text token-by-token, producing the typing effect familiar from chat UIs. |
| Tool calls | `TOOL_CALL_START`, `TOOL_CALL_ARGS`, `TOOL_CALL_END` | Streams the model's [tool use](/wiki/tool_use) decisions, including arguments as they are generated, enabling progressive UI rendering. |
| State | `STATE_SNAPSHOT`, `STATE_DELTA`, `MESSAGES_SNAPSHOT` | Synchronizes structured application state. `STATE_DELTA` uses JSON Patch (RFC 6902) so only differences are transmitted. |
| Special | `RAW`, `CUSTOM` | Allows passthrough of vendor-specific or domain-specific events that do not fit the standard categories. |

Some adapters extend the canonical set with an `INTERRUPT` event used to pause execution and request a user decision before a sensitive action is committed, mapped to a generic "human-in-the-loop" gate.[^13]

### Bidirectional state synchronization

A defining feature of AG-UI is that it treats state, not just text, as a first-class object on the wire. The agent backend can send a complete `STATE_SNAPSHOT` whenever it wants the frontend to reset its model, or a `STATE_DELTA` that contains a JSON Patch describing only the changes since the last snapshot.[^11][^12] Because both sides of the connection agree on the shape of the state, the frontend can render structured UI directly from the shared state (for example, dashboards, forms, or planning trees) and the backend can use the same state to drive its own behavior. The result is closer to an event-sourced shared store than to a chat transcript.

This design also allows write-back. A user can edit a value in the UI; the client sends the edit back to the agent as an action; the agent re-broadcasts an updated state delta; both sides remain consistent. CopilotKit's product surface exposes this pattern under the label "shared state."[^2][^8]

### Generative UI and tool-based UI

AG-UI supports two flavors of generative UI. In "tool-based generative UI", the agent invokes a frontend-registered tool whose contract corresponds to a UI component. The tool call streams arguments via `TOOL_CALL_ARGS`, and the frontend renders the component progressively as the arguments arrive. This is the mechanism behind features such as embedded charts, structured cards, and forms that pre-fill while the model is still emitting them.[^4][^13][^12]

In "static generative UI" or "agentic generative UI" mode, the backend keeps long-running work in flight (for example, document drafting or planning) and emits state deltas that drive a typed component tree the frontend already knows how to render. The intent is to constrain what the agent can put on screen to a small, audited vocabulary of components rather than allowing arbitrary HTML, which differentiates AG-UI's approach from systems that ship freeform model-generated markup such as [Claude Artifacts](/wiki/claude_artifacts) or v0-style code generation associated with [Vercel](/wiki/vercel)'s product line.[^2][^4]

### Human-in-the-loop

Tool execution can be configured as approval-required. When the agent reaches such a tool, the backend emits a tool-call start event with the proposed arguments and then waits for a user decision before proceeding. The frontend uses the standard UI controls to accept, modify, or reject, and the response is posted back to the same session. Microsoft's Agent Framework integration documents an `ApprovalRequiredAIFunction` abstraction that maps directly onto this AG-UI pattern.[^4][^2]

### Predictive state updates

AG-UI also defines a "predictive state updates" pattern in which the model's tool-call arguments stream through `TOOL_CALL_ARGS` events and the frontend can optimistically project those arguments into its local state model before the tool actually runs. This is similar in spirit to optimistic UI rendering, but standardized at the protocol level so that any AG-UI-compatible client gets it for free.[^4][^11]

## Reference Implementations and SDKs

The reference implementations live in the `ag-ui-protocol` GitHub organization. The primary SDKs are written in TypeScript and Python, and they expose both server-side helpers (for emitting and serializing events) and client-side helpers (for consuming the SSE stream and merging state).[^1][^2] Microsoft, AWS, and Google publish their own first-party integrations as part of their agent frameworks. Microsoft's `Microsoft.Agents.AI.Hosting.AGUI.AspNetCore` package exposes a `MapAGUI` extension method on ASP.NET Core, automatically converting Agent Framework events into AG-UI events. The Python equivalent, `agent-framework-ag-ui`, hooks AG-UI into a FastAPI endpoint.[^4]

Community SDKs in active development include Kotlin, Go, Dart, Java, Rust, Ruby, and C++, with .NET and Nim work underway. Frontend bindings beyond CopilotKit's [React](/wiki/react) and Angular clients include community work in Vue and Svelte, and a community React Native client.[^2] An "AG-UI Dojo" sample application, hosted at `dojo.ag-ui.com`, demonstrates each of the seven canonical features against multiple backend frameworks in roughly 50 to 200 lines of code per example.[^2][^4]

The CopilotKit React library remains the canonical client. It consumes AG-UI streams via an `HttpAgent` registration in its runtime, and exposes hooks for shared state, frontend tools, generative UI, and human-in-the-loop controls. CopilotKit also offers an enterprise tier (CopilotKit Enterprise Intelligence) that bundles observability and analytics on top of standard AG-UI streams.[^4][^9]

## Integrations

AG-UI's integration surface as of mid-2026 spans both proprietary and open-source agent frameworks:[^2][^4][^8]

| Vendor or framework | Integration status | Notes |
| --- | --- | --- |
| LangGraph | First-party (launch partner) | One of the two original launch integrations, May 2025. |
| CrewAI | First-party (launch partner) | One of the two original launch integrations, May 2025. |
| Microsoft Agent Framework | First-party | Supports all seven AG-UI feature areas via `MapAGUI` and FastAPI. Documented November 2025. |
| Google ADK | First-party | Google integration listed alongside the Series A announcement. |
| AWS Strands Agents | First-party | Listed in the official AG-UI integrations page. |
| AWS Bedrock AgentCore | First-party | Available alongside Strands. |
| Mastra | First-party | TypeScript-first agent framework. |
| Pydantic AI | First-party | Python-first typed-agent framework. |
| Agno | First-party | Listed under official integrations. |
| LlamaIndex | First-party | Listed under official integrations. |
| AG2 | First-party | AG2 published a dedicated AG-UI tutorial in February 2026. |
| Oracle Agent Spec | Integration via Agent Spec | Announced December 18, 2025; allows Agent Spec configurations to expose AG-UI endpoints. |
| OpenAI Agents SDK | In progress | Listed as in-development. |
| Cloudflare Agents | In progress | Listed as in-development. |
| AWS Bedrock Agents | In progress | Listed as in-development. |

CopilotKit lists the [OpenAI](/wiki/openai) hosted models, Ollama, and direct LLM access as out-of-the-box backends for AG-UI when an agent framework is not used. On the frontend side, CopilotKit's React and Angular libraries are the official clients, with a Terminal + Agent CLI client maintained by the community.[^2][^8]

## Comparison with Other Streaming and UI Approaches

AG-UI is one of several efforts to standardize the front edge of agentic systems. The most relevant points of comparison are not direct competitors so much as overlapping mechanisms that address subsets of the same problem.

| Approach | Layer | Format | Generative UI | Notes |
| --- | --- | --- | --- | --- |
| AG-UI | Agent-to-user | SSE / JSON events (16 types) | Tool-based and state-based | Vendor-neutral, framework-agnostic standard. |
| Vercel AI SDK UI stream | LLM-to-UI helper | Custom data-stream protocol over SSE | Yes, via streamUI / RSC | Tightly bound to Next.js and Vercel runtime; not a multi-vendor standard. |
| [LangGraph](/wiki/langgraph) streaming | Backend stream | Multiple modes (values, updates, messages) | None at the protocol level | Native LangGraph format; AG-UI sits above it. |
| [Anthropic API](/wiki/anthropic_api) tool-use streaming | LLM streaming | SSE with provider-specific message events | None | Single-vendor stream; AG-UI normalizes equivalents into `TOOL_CALL_*`. |
| [OpenAI Responses API](/wiki/openai_responses_api) streaming | LLM streaming | SSE with provider-specific event types | None | Same scope as Anthropic streaming; AG-UI sits above it. |
| [OpenAI Realtime API](/wiki/openai_realtime_api) | Voice or chat | WebRTC / WebSocket | Limited (voice tool use) | Designed for low-latency speech rather than generative UI. |
| [OpenAI Apps SDK](/wiki/apps_sdk) | App embedding | MCP-based app rendering | Yes, MCP UI | Apps are exposed inside ChatGPT; complementary to AG-UI. |

The clearest distinction is that AG-UI is purely a wire format, deliberately neutral with respect to the LLM provider, agent framework, and frontend stack. Provider-specific streaming formats from Anthropic and OpenAI cover roughly the "text + tool call" subset of AG-UI but do not include shared state, JSON Patch deltas, or human-in-the-loop semantics. The [Vercel](/wiki/vercel) AI SDK's UI stream is the closest single-vendor equivalent, but it is opinionated about runtime (Next.js plus Vercel's [React](/wiki/react) Server Components), whereas AG-UI is designed to plug into any framework that can hold an SSE connection open.[^1][^6][^4]

A separate but related effort, A2UI ("Agent-to-User Interface"), was open-sourced by Google in December 2025. CopilotKit has positioned A2UI and AG-UI as complementary rather than competing: A2UI defines a declarative UI vocabulary for agents to render structured interfaces, while AG-UI defines the transport and lifecycle around that vocabulary. The official AG-UI documentation lists A2UI under "MCP Apps Compatibility" and related interop tracks.[^4][^14]

## Applications

AG-UI is used in production for a range of agent-driven interfaces. Documented use cases include:

- **Agentic chat interfaces** that mix streaming text, citations, and rich UI cards, including the in-app copilots shipped by CopilotKit's enterprise customers.[^9][^1]
- **Generative dashboards and analytics**, where the agent emits structured state deltas that drive charts and tables rather than free-form markup. Examples appear throughout the CopilotKit and Microsoft documentation.[^4][^8]
- **Form autofill and CRM workflows**, where streaming tool-call arguments populate UI inputs as the model produces them.[^13]
- **Human-in-the-loop approval flows** for actions with real-world side effects, such as code commits, financial operations, or contract changes.[^4][^9]
- **Multi-agent visualizations** for [agentic workflows](/wiki/agentic_workflow) and [AI agent](/wiki/ai_agent) orchestration, in which sub-agents emit their own events under a parent run identifier.[^13][^4]
- **Coding assistants and copilots**, where the protocol is used to stream code diffs, tool calls, and execution results.[^13][^9]

CopilotKit reports that AG-UI is used by a "majority of the Fortune 500 and Global 50" customers of its own product, including named references to Deutsche Telekom, Docusign, Cisco, and S&P Global.[^9][^10]

## Significance

AG-UI's significance is structural rather than algorithmic. It does not propose a new model architecture, a new training method, or a new agent reasoning loop. It proposes a contract that lets any backend agent talk to any frontend UI without either side knowing the other's internals. By 2026 the agent ecosystem had accumulated three of these contracts: MCP for tools and data, A2A for inter-agent communication, and AG-UI for user-facing rendering, with AP2 (the [Agent Payments Protocol](/wiki/agent_payments_protocol)) emerging for transactional flows. Together they make it plausible to assemble an agent application from independently developed parts in roughly the same way the early web stack assembled HTTP, HTML, and CSS.[^7][^3][^9]

For developers, the practical effect is portability: an interface written against AG-UI can swap between LangGraph and CrewAI without rewriting the UI, and a backend written for AG-UI can be exposed in React, Angular, Vue, a CLI, or a mobile shell without rewriting the agent.[^4][^2] For enterprises, the effect is governance: a single observability and audit layer can attach to AG-UI streams across heterogeneous agent stacks.[^5][^9]

## Limitations

The protocol has clear limitations as of mid-2026, which are not hidden in the documentation:

- **Specification maturity.** AG-UI was less than a year old at the time of the December 2025 Oracle integration and was still iterating on event-type semantics, particularly around interrupts and predictive state updates. The 16-event vocabulary is small, but adapters frequently extend it via `CUSTOM` events, raising risk of fragmentation.[^11][^13]
- **Transport assumptions.** SSE is the default and the most widely tested transport. While the specification permits WebSockets, webhooks, and binary streams, not all SDKs or adapters support these uniformly, and SSE has its own constraints (one-way per request, no built-in resume guarantees, proxy compatibility issues with some corporate networks).[^11][^12]
- **State model rigidity.** Shared state is powerful but assumes both sides have a common typed schema. In practice, schema drift between agent versions and frontend versions is a recurring operational concern, and the protocol leaves migration policy to implementers.[^4][^11]
- **Security boundary.** Frontend tools defined by the client can be invoked by the agent, which means the agent's effective authority extends into the browser. Implementations must carefully scope what tools the agent is allowed to call. Microsoft's documentation notes that approval middleware exists precisely to manage this.[^4]
- **Vendor concentration.** While the standard is MIT-licensed and openly governed, the ecosystem remains heavily anchored to CopilotKit as the dominant React client and primary maintainer, with most early adoption flowing through CopilotKit's commercial offerings.[^9][^2]

## Criticisms and Discussion

Public discussion of AG-UI in 2025 and early 2026 has been mixed in detail. The most substantive critique has come from developers who note that the small core protocol relies on `CUSTOM` events to express anything beyond the canonical features, which risks recreating the very fragmentation it intended to solve. GitHub discussion threads on the repository explicitly debate what counts as "in scope" for the standard, with maintainers attempting to balance minimalism against expressive power.[^2] Some commentators have also pointed out that the boundary between AG-UI (agent-to-user wire format) and tools such as Claude Artifacts, Apps SDK, or Vercel v0 (model-driven UI generation in specific products) is not always cleanly drawn in marketing materials, and have argued for a clearer separation between the protocol layer and the UI-generation layer.[^14][^4]

A secondary line of discussion concerns the relationship with Google's A2UI, announced December 22, 2025. CopilotKit has framed the two as compatible by treating A2UI as a vocabulary for UI components and AG-UI as the streaming carrier, but the standards have overlapping ambitions and the long-term resolution is still being negotiated through interop work.[^14][^4]

## Related Work

- [Model Context Protocol](/wiki/model_context_protocol): agent-to-tool standard from Anthropic; AG-UI sits on the opposite end of the agent stack.
- [Agent2Agent Protocol](/wiki/a2a_protocol): agent-to-agent standard from Google; complementary to AG-UI in the same three-layer stack.
- [MCP server](/wiki/mcp_server): server implementation pattern used to expose tools to agents; orthogonal to AG-UI but commonly used together.
- [Agent Payments Protocol](/wiki/agent_payments_protocol): a fourth emerging protocol covering agent-driven payments, often discussed in the same protocol-stack context as AG-UI.
- [OpenAI Apps SDK](/wiki/apps_sdk): MCP-based app embedding inside ChatGPT, providing UI rendering inside a host product; not a wire-format competitor to AG-UI but addresses an adjacent surface.
- [LangGraph](/wiki/langgraph) and [CrewAI](/wiki/crewai): two of AG-UI's launch-partner backends.
- [Mastra](/wiki/mastra): TypeScript agent framework with first-party AG-UI integration.
- CopilotKit is the maintainer of AG-UI; see the references for primary documentation.
- [OpenAI Responses API](/wiki/openai_responses_api) and [Anthropic API](/wiki/anthropic_api) tool-use streaming: provider-specific streaming layers that AG-UI normalizes above.
- [OpenAI Realtime API](/wiki/openai_realtime_api): voice-first streaming interface, comparable in spirit to AG-UI but for low-latency audio.
- [Claude Artifacts](/wiki/claude_artifacts) and [Claude Skills](/wiki/claude_skills): Anthropic features for generating and packaging UI and capabilities; orthogonal to AG-UI but often discussed in the same product space.
- [Tool use](/wiki/tool_use) and [Function calling](/wiki/function_calling): the underlying LLM capability that AG-UI surfaces via its `TOOL_CALL_*` events.
- [Agentic workflow](/wiki/agentic_workflow) and [Multi-agent system](/wiki/multi_agent_system): higher-level concepts that AG-UI helps to operationalize.
- [AI agent](/wiki/ai_agent) and [Agent orchestration](/wiki/agent_orchestration): the broader categories within which AG-UI lives.

## See also

- [Model Context Protocol](/wiki/model_context_protocol)
- [Agent2Agent Protocol](/wiki/a2a_protocol)
- [MCP server](/wiki/mcp_server)
- [Agent Payments Protocol](/wiki/agent_payments_protocol)
- [LangGraph](/wiki/langgraph)
- [LangChain](/wiki/langchain)
- [CrewAI](/wiki/crewai)
- [Mastra](/wiki/mastra)
- [OpenAI Agents SDK](/wiki/openai_agents_sdk)
- [Agent Tools API](/wiki/agent_tools_api)
- [OpenAI Apps SDK](/wiki/apps_sdk)
- [OpenAI Responses API](/wiki/openai_responses_api)
- [OpenAI Realtime API](/wiki/openai_realtime_api)
- [Anthropic API](/wiki/anthropic_api)
- [Anthropic Computer Use](/wiki/anthropic_computer_use)
- [Computer use](/wiki/computer_use)
- [Tool use](/wiki/tool_use)
- [Function calling](/wiki/function_calling)
- [React](/wiki/react)
- [Vercel](/wiki/vercel)
- [Claude Artifacts](/wiki/claude_artifacts)
- [Claude Skills](/wiki/claude_skills)
- [Agentic workflow](/wiki/agentic_workflow)
- [AI agent](/wiki/ai_agent)
- [Agent orchestration](/wiki/agent_orchestration)
- [Multi-agent system](/wiki/multi_agent_system)

## References

[^1]: Nathan Tarbert / CopilotKit, "Introducing AG-UI: The Protocol Where Agents Meet Users", CopilotKit Blog (also on DEV Community), 2025-05-12. https://www.copilotkit.ai/blog/introducing-ag-ui-the-protocol-where-agents-meet-users. Accessed 2026-05-20.
[^2]: AG-UI Protocol project, "AG-UI: the Agent-User Interaction Protocol (README)", GitHub, 2026-04-09. https://github.com/ag-ui-protocol/ag-ui. Accessed 2026-05-20.
[^3]: Mete Atamel, "Agent Protocols: MCP, A2A, A2UI, AG-UI", atamel.dev / Google Cloud Community, 2026-03-17. https://atamel.dev/posts/2026/03-17_agent_protocols_mcp_a2a_a2ui_agui/. Accessed 2026-05-20.
[^4]: Microsoft Learn, "AG-UI Integration with Agent Framework", Microsoft, 2025-11-07 (updated 2026-04-09). https://learn.microsoft.com/en-us/agent-framework/integrations/ag-ui/. Accessed 2026-05-20.
[^5]: CopilotKit, "Oracle adopts AG-UI protocol for Agent Spec", CopilotKit Blog, 2025-12-18. https://www.copilotkit.ai/blog/oracle-adopts-ag-ui-protocol-for-agent-spec. Accessed 2026-05-20.
[^6]: Nathan Tarbert / CopilotKit, "Introducing AG-UI: The Protocol Where Agents Meet Users", DEV Community, 2025-05-13. https://dev.to/copilotkit/introducing-ag-ui-the-protocol-where-agents-meet-users-10gp. Accessed 2026-05-20.
[^7]: Jubin Soni, "The Agent Protocol Stack: MCP vs A2A vs AG-UI: When to Use What", DEV Community / CodeToDeploy on Medium, 2026-04-01. https://dev.to/jubinsoni/the-agent-protocol-stack-mcp-vs-a2a-vs-ag-ui-when-to-use-what-6dn. Accessed 2026-05-20.
[^8]: CopilotKit, "AG-UI Protocol (product page)", copilotkit.ai, 2026-05-01. https://www.copilotkit.ai/ag-ui. Accessed 2026-05-20.
[^9]: TechCrunch, "CopilotKit raises $27M to help devs deploy app-native AI agents", TechCrunch, 2026-05-05. https://techcrunch.com/2026/05/05/copilotkit-raises-27m-to-help-devs-deploy-app-native-ai-agents/. Accessed 2026-05-20.
[^10]: GeekWire, "Seattle's CopilotKit raises $27M, as some of the biggest names in tech adopt its AI agent protocol", GeekWire, 2026-05-05. https://www.geekwire.com/2026/seattles-copilotkit-raises-27m-as-some-of-the-biggest-names-in-tech-adopt-its-ai-agent-protocol/. Accessed 2026-05-20.
[^11]: AG-UI Protocol project, "Core architecture", docs.ag-ui.com, 2026-04-09. https://docs.ag-ui.com/concepts/architecture. Accessed 2026-05-20.
[^12]: AG-UI Protocol project, "AG-UI Overview", docs.ag-ui.com, 2026-04-09. https://docs.ag-ui.com/. Accessed 2026-05-20.
[^13]: DataCamp, "AG-UI Overview: A Lightweight Protocol for Agent-User Interaction", DataCamp Tutorial, 2026-01-15. https://www.datacamp.com/tutorial/ag-ui. Accessed 2026-05-20.
[^14]: CopilotKit, "Build with Google's new A2UI Spec: Agent User Interfaces with A2UI + AG-UI", CopilotKit Blog, 2025-12-22. https://www.copilotkit.ai/blog/build-with-googles-new-a2ui-spec-agent-user-interfaces-with-a2ui-ag-ui. Accessed 2026-05-20.