Feature/november positioning

docs/agentic-protocols.mdx

@@ -0,0 +1,34 @@
+---
+title: "MCP, A2A, and AG-UI"
+description: "Understanding how AG-UI complements and works with MCP and A2A"
+---
+
+## Agentic Protocols
+
+The agentic ecosystem is rapidly organizing around a family of open, complementary protocols — each addressing a distinct layer of interaction.  AG-UI has emerged as the 3rd leg of the AI protocol landscape:
+<div style={{textAlign: 'center', margin: '2rem 0'}}>
+  <img src="/images/ai-protocol-stack.png" alt="AI Protocol Stack" style={{maxWidth: '40%', height: 'auto', borderRadius: '8px'}} />
+</div>
+
+You can connect your application to agents directly via **AG-UI**, **MCP**, and **A2A**.
+
+
+- **MCP** (Model Context Protocol) Connects agents to tools and to context — but those tools are themselves becoming agentic.
+- **A2A** (Agent to Agent) Connects agents to other agents.
+- **AG-UI (Agent–User Interaction)** Connects agents to users (through user-facing applications).  
+
+    You can think of AG-UI as the **"kitchen sink" protocol** — informed by bottom-up, real-world needs for building best-in-class agentic applications.
+
+
+These three agentic protocols are complementary and have distinct technical goals; a single agent can and often does use all 3 simultaneously.
+
+## AG-UI Handshakes with MCP and A2A
+
+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.  
+
+AG-UI's mandate is to support the full set of building blocks required by modern agentic applications.
+
+## Generative UI Specs
+
+Recently several [generative ui specs](./concepts/generative-ui-specs) (including MCP-UI, Open JSON UI, and A2UI) have been released which allow agents to deliver UI widgets through the interaction protocols.  AG-UI works with all of these.  Visit our [generative ui specs page](./concepts/generative-ui-specs) to lern more.
+

docs/concepts/generative-ui-specs.mdx

@@ -0,0 +1,21 @@
+---
+title: "Generative UI"
+description: "Understanding AG-UI's relationship with generative UI specifications"
+---
+
+## **AG-UI and Generative UI Specs**
+
+Several recently released specs have enabled agents to return generative UI, increasing the power and flexibility of the Agent<->User conversation.
+
+A2UI, MCP-UI, and Open-JSON-UI are all **generative UI specifications.** Generative UIs allow agents to respond to users not only with text but also with dynamic UI components.
+
+| **Specification** | **Origin / Maintainer** | **Purpose** |
+| --- | --- | --- |
+| **A2UI** | Google | A declarative, LLM-friendly Generative UI spec. JSONL-based and streaming, designed for platform-agnostic rendering. |
+| **Open-JSON-UI** | OpenAI | An open standardization of OpenAI's internal declarative Generative UI schema. |
+| **MCP-UI** | Microsoft + Shopify | A fully open, iframe-based Generative UI standard extending MCP for user-facing experiences. |
+
+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.
+

docs/docs.json

@@ -17,6 +17,7 @@
             "group": "Get Started",
             "pages": [
               "introduction",
+              "agentic-protocols",
               {
                 "group": "Quickstart",
                 "pages": [
@@ -44,7 +45,8 @@
               "concepts/messages",
               "concepts/state",
               "concepts/serialization",
-              "concepts/tools"
+              "concepts/tools",
+              "concepts/generative-ui-specs"
             ]
           },
           {

docs/introduction.mdx

@@ -8,8 +8,9 @@ description:
 
 AG-UI is an <u><strong>open</strong></u>, <u><strong>lightweight</strong></u>, <u><strong>event-based</strong></u> protocol that standardizes how AI agents connect to user-facing applications.
 
+AG-UI is designed to be the general-purpose, bi-directional connection between a user-facing application and any agentic backend.
 
-Built for simplicity and flexibility, it standardizes how agent state, UI intents, and user interactions flow between your model/agent runtime and user-facing frontend applications—to allow application developers to ship reliable, debuggable, user‑friendly agentic features fast while focusing on application needs and avoding complex ad-hoc wiring.
+Built for simplicity and flexibility, it standardizes how agent state, UI intents, and user interactions flow between your model/agent runtime and user-facing frontend applications—to allow application developers to ship reliable, debuggable, user‑friendly agentic features fast while focusing on application needs and avoiding complex ad-hoc wiring.
 
 
 
@@ -20,6 +21,22 @@ Built for simplicity and flexibility, it standardizes how agent state, UI intent
 
 ---
 
+## Agentic Protocols
+
+AG-UI is one of three prominent open [agentic protocols](./agent-interaction-protocols).
+
+| **Layer** | **Protocol / Example** | **Purpose** |
+| --- | --- | --- |
+| **Agent ↔ User Interaction** | **AG-UI<br />(Agent–User Interaction Protocol)** | The open, event-based standard that connects agents to user-facing applications — enabling real-time, multimodal, interactive experiences. |
+| **Agent ↔ Tools & Data** | **MCP <br />(Model Context Protocol)** | Open standard (originated by Anthropic) that lets agents securely connect to external systems — tools, workflows, and data sources. |
+| **Agent ↔ Agent** | **A2A<br />(Agent to Agent)** | Open standard (originated by Google) which defines how agents coordinate and share work across distributed agentic systems. |
+
+<Note>
+<strong>Confused about "A2UI" and "AG-UI"?</strong>  That's understandable!  Despite the naming similarities, they are quite different and work well together.  A2UI is a [generative UI specification](./concepts/generative-ui-specs) - allowing agents to deliver UI widgets, where AG-UI provides the complete bi-directional runtime connection between the agent and the application.
+</Note>
+
+---
+
 ## Building blocks (today & upcoming)
 
 <div style={{display: 'grid', gridTemplateColumns: 'repeat(2, 1fr)', gap: '1rem', margin: '1.5rem 0'}}>
@@ -187,28 +204,9 @@ While agents are just software, they exhibit characteristics that make them chal
 
 AG-UI is an event-based protocol that enables dynamic communication between agentic frontends and backends. It builds on top of the foundational protocols of the web (HTTP, WebSockets) as an abstraction layer designed for the agentic age—bridging the gap between traditional client-server architectures and the dynamic, stateful nature of AI agents.
 
-## The AI protocol landscape
-
-AG-UI has emerged as the 3rd leg of the AI protocol landscape:
-<div style={{textAlign: 'center', margin: '2rem 0'}}>
-  <img src="/images/ai-protocol-stack.png" alt="AI Protocol Stack" style={{maxWidth: '40%', height: 'auto', borderRadius: '8px'}} />
-</div>
-
-- MCP: Connects agents to tool and to context.
-- A2A: Connects agents to other agents.
-- **AG-UI:** Connects agents to users (through user-facing applications)
-
-
-These protocols are complimentary and have distinct technical goals; a single agent can and often does use all 3 simultanously.
-Where these protocols intersect, there are opportunities for seamless handshakes facilitating interoperability—work on these integration points is actively ongoing.
-AG-UI's mandate is to support the full set of building blocks required by modern agentic applications.
-
-
-
-
 ---
 
-## AG-UI in action
+## AG-UI in Action
 
 <div style={{textAlign: 'center', margin: '3rem 0 1rem 0'}}>
   <video