MCP, A2A, and AG-UI: The Agentic Protocol Stack

Agentic systems are emerging as the next paradigm in AI application design - moving beyond static chatbots toward dynamic, context-aware, and modular ecosystems of intelligent agents. To operate effectively at scale, these systems must integrate three foundational capabilities: perceiving their environment, collaborating across specialized components, and interacting with users in real time. This talk introduces an architecture that leverages three interoperable protocols to achieve these goals. The Model Context Protocol (MCP) enables dynamic context hydration and semantic grounding, allowing agents to operate on structured and unstructured inputs tailored to specific tasks. The Agent-to-Agent Protocol (A2A) facilitates orchestrated collaboration between modular agents, enabling delegation, specialization, and distributed reasoning. The Agent-User Interaction Protocol (AG-UI) provides a real-time interface layer that closes the loop with users, supporting direct feedback, steerability, and reactive experiences. Together, these protocols form a cohesive foundation for building intelligent systems that are decoupled, composable, and resilient - minimizing integration debt while enabling rich, responsive behaviors. This session explores design patterns, practical challenges, and architectural strategies for applying MCP, A2A, and AG-UI in real-world agentic applications, offering a blueprint for anyone aiming to architect intelligent applications.

Transcript

1. MCP, A2A, and AG-UI The Agentic Protocol Stack Max Marschall @MaxOSchulte Consultant / Architect @ Thinktecture
2. In this session The Agentic Stack MCP The Model Context Protocol standardises how agents connect to external systems — tools, resources, prompts. A2A The Agent-to-Agent Protocol lets autonomous agents discover, delegate to, and collaborate with one another across frameworks. LAYER 3 AG-UI The Agent–User Interaction Protocol standardises how agents stream state, tool calls, and UI into user- facing apps. Three protocols, one stack — composable AI systems instead of bespoke integrations. LAYER 1 Agent ↔ tools & context LAYER 2 Agent ↔ agent Agent ↔ user 2 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
3. The Full Protocol Stack Model Context Protocol Agent Tools ← MCP Model Context Protocol You are here ← 3 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
4. What is MCP? Model Context Protocol Think of MCP like a USB-C port for AI applications. A standardised way to connect AI applications to external systems. 4 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
5. Architecture Model Context Protocol Host LLM applications (Claude Desktop, IDEs) that initiate connections and own the model. Client A 1:1 connection handler inside the host. Manages protocol communication for one server. Server Provides context, tools, and capabilities to clients. Runs as a separate, sandboxable process. ⚠️ Servers can’t talk to each other. All cross-server orchestration is owned by the host’s LLM. 5 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
6. Why should we care? Model Context Protocol WITHOUT MCP Custom per integration Every app reinvents tool plumbing No standardisation across implementations Fragile when systems change Duplicated work across teams Build once, connect everywhere Open-source & vendor-neutral Based on proven patterns (JSON-RPC 2.0) DRY — don’t repeat yourself KISS — keep it simple WITH MCP 6 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
7. Who’s Adopting It Model Context Protocol — industry support Backed across model providers, IDEs, and developer tools — the fastest-spreading agent standard. Anthropic OpenAI Google Microsoft JetBrains Replit Sourcegraph Cursor VS Code Zed Windsurf Block 7 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
8. From M × N to M + N Model Context Protocol M + N (one shared protocol) App 1 MCP App 2 App 3 Database Documentation FAQ 8 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
9. Features Model Context Protocol Tools Resources Prompts Elicitation Sampling Server Composition Progress Report MCP-UI / Apps 9 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
10. Grounding Model Context Protocol Connect an LLM to reliable sources of information to ensure accurate, relevant results. Improves relevance Prevents hallucinations Connects to real-world data Alternatives: Retrieval-Augmented Generation (RAG), Fine-Tuning. Context Hydration Automated way to add concise contextual information based on the changing request. Examples: Web search / web access Documentation access Internal knowledge lookups PATTERN 10 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
11. Clients & Feature Support Model Context Protocol Not every client implements every MCP feature. Coverage moves fast, but expect gaps. MATURE Tools, Resources, Prompts Supported by most major hosts — the safe baseline to build on today. Elicitation Available in a subset of clients. Check before relying on round-trip flows. MCP-UI, MCP-Apps New and popular, fast pasted development. MCP- Apps as goto App-SDK for ChatGPT. https://modelcontextprotocol.info/docs/clients/ https://developers.openai.com/apps-sdk/build/chatgpt-ui PARTIAL HOT 11 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
12. Best Practices Model Context Protocol TOOLS Context Every tool eats context. Strip what the agent doesn’t need for the current task. TOOLS Performance Narrow inputs, narrow outputs. Avoid "do- everything" tools that confuse the model. TOOLS Compability Test against the host. Some clients ignore optional fields or coerce types silently. SERVER Features Don’t assume Elicitation, Sampling, or composition will work — check the matrix. 12 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
13. Context Size Solution: Dynamic Tools Model Context Protocol Tools shouldn’t all be loaded all the time. Push the matrix down to what’s actually relevant right now. Different tools by authentication / authorization Update tool lists based on preceding queries Agent Skills enable / disable MCP servers tools/list_changed notifications Tool Search instead of full listing Lazy registration on demand The fewer tools in context, the cleaner the model’s decisions. 13 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
14. Skills Anthropic Agent Skills A folder. A SKILL.md . Loaded lazily. No protocol. No transport. Just files — composing with whatever tools the agent already has. Metadata Name & description always loaded Body Only loaded when task matches metadata Assets Scripts & references, explictly opened and used by the skill 14 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
15. Plugins Bundled capabilities Skills Playbooks the agent loads on demand. MCP servers Tools & data sources, wired up automatically. CAPABILITY Slash commands Named, bound prompts the user can invoke directly. CAPABILITY Hooks Event-driven automation — pre/post tool, on stop, on edit. CAPABILITY CAPABILITY 15 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
16. Spec Update — 2026-07-28 Model Context Protocol — Release Candidate The first breaking revision since 2025-11-25 . RC locked 21 May 2026, final spec 28 Jul 2026 A ten-week window to validate against production workloads. Authentication hardening MCP-Apps MCP goes stateless. Session management leaves the protocol layer — any server instance can serve any request. blog.modelcontextprotocol.io · spec 2026-07-28 16 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
17. Going Stateless Model Context Protocol — 2026-07-28 REMOVED The session layer initialize / initialized handshake — gone Mcp-Session-Id header — gone No sticky routing, shared session stores, or packet inspection Per-request context New server/discover for capability exchange Version, client info & capabilities ride in _meta on every request Any instance serves any request A remote MCP server can now run behind a plain round-robin load balancer — no session affinity required. REPLACED BY 17 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
18. Transport & Observability Model Context Protocol — 2026-07-28 Header routing Mcp-Method and Mcp-Name headers route requests without inspecting the body. Built-in caching List & resource reads carry ttlMs and cacheScope — modelled on HTTP Cache- Control . No persistent SSE just to detect changes. W3C TRACE CONTEXT Distributed tracing traceparent , tracestate and baggage in _meta — plugs straight into OpenTelemetry backends. STREAMABLE HTTP FRESHNESS 18 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
19. Extensions, First-Class Model Context Protocol — 2026-07-28 Optional capabilities now live outside the core spec — reverse-DNS ids, negotiated via an extensions map, shipped from separate ext-* repos and versioned independently. MCP Apps Servers ship interactive HTML in sandboxed iframes. UI templates are declared upfront for prefetch, caching & review — and the UI talks over the same JSON-RPC, keeping audit & consent trails. Tasks Graduates from experimental, redesigned stateless: tools/call returns a task handle; the client drives tasks/get · tasks/update · tasks/cancel . tasks/list removed. Migration required. OFFICIAL EXTENSION OFFICIAL EXTENSION 19 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
20. Deprecations Model Context Protocol — 2026-07-28 Annotation-only — methods keep working through a 12-month minimum window before removal. DEPRECATED Roots → Tool parameters, resource URIs, or server configuration. DEPRECATED Sampling → Direct LLM provider API integration. DEPRECATED Logging → stderr for stdio transports; OpenTelemetry for structured observability. New feature-lifecycle policy: Active → Deprecated → Removed, never less than twelve months apart. 20 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
21. Schema, Errors & Migration Model Context Protocol — 2026-07-28 JSON SCHEMA 2020-12 Richer tool schemas Inputs: oneOf / anyOf / allOf , conditionals, $ref / $defs structuredContent → any JSON value (was object-only) No auto-deref of external $ref ; bound schema depth & validation time BREAKING CHANGES What to migrate Handshake & Mcp-Session-Id removed Tasks API redesigned Missing-resource error -32002 → -32602 New _meta request shape 21 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
22. PROTOCOL · 02 A2A An open standard for secure, interoperable communication between autonomous AI agents across frameworks and platforms. 22 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
23. The Full Protocol Stack Agent-to-Agent Protocol Agent Agent ↑ A2A Agent-to-Agent You are here ↑ 23 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
24. Origins Agent-to-Agent Protocol Invented by Google Gifted to the Linux Foundation — vendor-neutral governance Designed to complement MCP, not replace it a2a-protocol.org "Build with ADK (or any framework), equip with MCP (or any tool), and communicate with A2A — to remote agents, local agents, and humans." 24 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
25. Industry Backing Agent-to-Agent Protocol — Linux Foundation partners 50+ launch partners across enterprise software, cloud, and agent frameworks. Google Microsoft AWS ServiceNow Atlassian Cisco MongoDB PayPal Cohere Workday LangChain a2a-protocol.org · governed by the Linux Foundation 25 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
26. Across Boundaries A2A bridges agents, MCP reaches tools Source: a2a-protocol.org — agents collaborate across organizational or technological boundaries 26 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
27. Application Architecture A2A + MCP in one agent Source: a2a-protocol.org — A2A and MCP, complementary protocols for agentic systems 27 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
28. Goals Agent-to-Agent Protocol GOAL Interoperability Bridge communication gaps between disparate agentic systems. GOAL Collaboration Let agents delegate tasks, exchange context, and work together. GOAL Discovery Agents find each other via published cards — no static wiring. GOAL Security Enterprise-grade secure communication patterns from day one. 28 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
29. Guiding Principles Agent-to-Agent Protocol PRODUCTION Enterprise ready Auth, security, privacy, tracing and monitoring are first-class concerns. LIFECYCLE Async first Designed for long-running tasks and human- in-the-loop flows. PAYLOAD Modality agnostic Text, audio/video, structured data, embedded UI — all carried as parts. BOUNDARY Opaque execution No need to share internal thoughts, plans, or tools — agents stay encapsulated. 29 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
30. Client vs Remote Agent Agent-to-Agent Protocol The caller Discover agents via Agent Cards Authenticate requests Send messages / create tasks Handle streaming responses Expose webhook for notifications The provider Publish Agent Card at /.well- known/agent-card.json Authenticate incoming requests Process tasks & generate artifacts Stream responses via SSE Send push notifications CLIENT AGENT REMOTE AGENT 30 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
31. Agent Card Agent-to-Agent Protocol Discovery endpoint — every A2A server publishes one. Tells clients who you are, what you can do, and how to reach you. Convention: /.well-known/agent-card.json { "name": "Image Generator", "description": "Generates and edits images from tex "url": "https://images.example.com/a2a", "version": "1.2.0", "capabilities": { "streaming": true, "pushNotifications": true }, "authentication": { "schemes": ["bearer"] }, "skills": [ { "id": "generate-image", "name": "Generate image", "tags": ["image", "generative"], "inputModes": ["text"], "outputModes": ["image/png"] } ] } 31 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
32. Core Concepts Agent-to-Agent Protocol MANIFEST Agent Card Self-describing metadata: name, skills, endpoints, auth. WORK UNIT Task Stateful lifecycle with status, history and artifacts. EXCHANGE Message user or agent role, one- to-many parts, conversation history. ATOM Part Smallest unit — TextPart , FilePart , DataPart . OUTPUT Artifact Generated result, composed from parts. GROUPING Context Identifier that groups tasks and maintains state across interactions. 32 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
33. Task Agent-to-Agent Protocol id — unique identifier contextId — grouping identifier status — current TaskStatus - Interrupts: input-/ auth-required history — message array artifacts — generated outputs metadata — extension data 33 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
34. Core Protocol Methods Agent-to-Agent Protocol JSON-RPC tasks/send Submit a task message to an agent. JSON-RPC tasks/get Retrieve task status & history. JSON-RPC tasks/cancel Cancel a running task. JSON-RPC tasks/sendSubscribe Send and subscribe to streaming updates via SSE. 34 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
35. Task Agent-to-Agent Protocol — example flow 1 — Initial request 2 — Result with artifact "id": "req-001", { "jsonrpc": "2.0", "method": "message.send", "params": { "message": { "role": "user", "messageId": "msg-user-001", "parts": [{ "kind": "text", "text": "Generate an image of a sailboat." }] } } } "id": "req-001", "id": "task-boat-gen-123", "contextId": "ctx-conversation-abc", { "jsonrpc": "2.0", "result": { "status": { "state": "completed" }, "artifacts": [ { "artifactId": "artifact-boat-v1", "name": "sailboat_image.png", "parts": [ { "kind": "file", "file": { "name": "sailboat_image.png", "mimeType": "image/png" 35 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
36. Task Follow-up Agent-to-Agent Protocol — example flow 3 — Followup request 4 — Followup result with artifact "id": "req-002", "contextId": "ctx-conversation-abc", "referenceTaskIds": [ "task-boat-gen-123" ], "text": "Please modify the sailboat to be red." { "jsonrpc": "2.0", "method": "message.send", "params": { "message": { "role": "user", "messageId": "msg-user-002", "parts": [ { "kind": "text", "id": "req-002", "id": "task-boat-color-456", "contextId": "ctx-conversation-abc", "artifactId": "artifact-boat-v2-red-pqr", "description": "A generated image of a red sailboat on the ocean.", { "jsonrpc": "2.0", "result": { "status": { "state": "completed" }, "artifacts": [ { "name": "sailboat_image.png", "parts": [ { 36 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
37. Security & Authentication Agent-to-Agent Protocol HTTPS required OAuth 2.0 · OIDC · API Keys · mTLS OpenAPI Security Scheme Authenticate every request In task authentication -> auth-required A2A treats agents as standard enterprise applications. Identity is handled at the HTTP transport layer. 37 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
38. A2A + MCP — complementary Agent-to-Agent Protocol A2A A2A MCP MCP User Orchestrator Research Agent Coding Agent Search · Docs GitHub · CI A2A is how agents talk to each other. MCP is how each agent reaches its tools. Different layers, same stack. 38 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
39. Key Takeaways Agent-to-Agent Protocol Open standard for agent interoperability Built on existing web standards (HTTP, JSON-RPC, SSE) Enterprise-grade security built-in Complements MCP for a complete stack RESOURCES Official a2a-protocol.org github.com/a2aproject/A2A github.com/a2aproject/a2a- inspector a2aprotocol.net/docs/specification 39 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
40. PROTOCOL · 03 AG-UI An open, lightweight, event-based protocol that standardises how AI agents connect to user-facing applications. 40 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
41. The Full Protocol Stack AG-UI Protocol Agent User → AG-UI Agent–User Interaction You are here → 41 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
42. The missing link AG-UI Protocol MCP Agent ↔ tools & context A2A Agent ↔ agent AG-UI Agent ↔ user No standard for agent-to-user interaction has meant ad-hoc WebSocket formats, custom JSON parsing, and bespoke adapters per framework. 42 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
43. Traditional APIs don’t fit agents AG-UI Protocol Agentic applications break the request/response model. CLASSIC API Request → response → done Client makes one request. Server returns data. Interaction ends. Stream → think → call → stream Multi-step reasoning, mid-flight tool calls, partial state, user interrupts — none of it fits a single HTTP round-trip. AGENTIC FLOW 43 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
44. Without AG-UI AG-UI Protocol — pain points PAIN Custom WebSocket formats Every agent framework invents its own wire format. PAIN Ad-hoc JSON parsing Text hacks, sentinel strings, brittle delimiters. PAIN Adapter sprawl Reinvent the integration for each new framework — LangChain ≠ CrewAI ≠ Mastra. PAIN State sync hell Complex state synchronisation between agent and UI, no shared contract. 44 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
45. Ecosystem AG-UI Protocol — framework support AG-UI server Major framework support (Pydantic-AI, LangGraph, CrewAI, Mastra, …) "Simple" one-line expose Fine-grained control where you need it CopilotKit Manages communication & reconnection Helps with state synchronisation Human-in-the-loop primitives Ready-made React components ai.pydantic.dev/ui/ag-ui · docs.copilotkit.ai SERVER SIDE CLIENT SIDE 45 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
46. Framework Support AG-UI Protocol — who’s building on it Native AG-UI integrations across the major agent frameworks — plus CopilotKit on the client. CopilotKit LangGraph LangChain CrewAI Mastra LlamaIndex AG2 46 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
47. Communication transport AG-UI Protocol SSE — Server-Sent Events Text-based, plain HTTP. Survives proxies and corporate networks. PERFORMANCE Binary protocol High throughput, custom serialisation — for high-volume streams. WebSocket Low-latency, two-way — when the UI needs to interject mid-stream. FALLBACK HTTP Polling For restrictive networks that block streaming. Slower, but always works. DEFAULT BIDIRECTIONAL 47 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
48. Server communication events AG-UI Protocol ∑ 16 standard events. Every framework emits the same shapes — text messages, tool calls, state updates, lifecycle. TEXT MESSAGE_* START , CONTENT , END TOOL TOOL_CALL_* START , ARGS , END STATE STATE_* SNAPSHOT , DELTA LIFECYCLE RUN_* STARTED , FINISHED , ERROR STEP STEP_* STARTED , FINISHED GENERIC CUSTOM / RAW Escape hatch for framework- specific payloads. 48 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
49. Streaming patterns AG-UI Protocol Text message Tool call Same shape, same lifecycle. The UI doesn’t care which framework produced the stream. 1. TEXT_MESSAGE_START { messageId, role: "assistant" } 2. TEXT_MESSAGE_CONTENT (× N) { messageId, delta: "Hello" } { messageId, delta: " world" } 3. TEXT_MESSAGE_END { messageId } 1. TOOL_CALL_START { toolCallId: "call_123", toolName: "search_database" } 2. TOOL_CALL_ARGS { toolCallId: "call_123", args: { query: "users" } } 3. TOOL_CALL_END { toolCallId: "call_123", result: [...] } 49 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
50. State synchronisation AG-UI Protocol Bi-directional state — the agent and the UI share one observable state object over the lifetime of a run. STATE_SNAPSHOT Full state Complete state object for initialisation or refresh. Send when joining or recovering. STATE_DELTA Incremental update JSON Patch (RFC 6902) for efficient incremental updates — bytes on the wire, not full snapshots. 50 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
51. UI capabilities AG-UI Protocol Exact component + props Agent specifies the exact component and props to render. Component is mapped to a specific event in the UI. Predictable, audited, narrow. Intent + framework picks Agent describes intent. The framework selects components from a registered catalogue. Flexible, generative, broader surface. STRICT · PREDICTABLE GENERATIVE · FLEXIBLE STATIC DECLARATIVE 51 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
52. Solved problems AG-UI Protocol SOLVED Real-time streaming complexity One event taxonomy, one transport contract — no more rolling your own. SOLVED Tool orchestration Agents call functions and hit APIs — the UI shows progress and handles approval. SOLVED Concurrency & cancellation Run lifecycle events make interrupt and resume first-class. SOLVED Unified interface LangChain, CrewAI, Mastra speak different dialects — AG-UI normalises the wire. 52 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
53. Where AG-UI isn’t worth it AG-UI Protocol — non-use cases SKIP Simple request/response No streaming, no multi-step — a plain JSON endpoint is fine. SKIP Batch processing No user interaction — run it as a job, write the result somewhere. SKIP Static content delivery No agent involved — you don’t need an event protocol for a page. SKIP Ultra-low latency (<10 ms) Real-time control loops belong on a different transport entirely. 53 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
54. Human in the loop AG-UI Protocol The visible reason AG-UI matters: acceptance via observability. Keep humans in the loop, not behind it Visual feedback for every tool call Real questions, real commits Loading placeholders for the inevitable wait When users see what the agent is doing, they trust the parts they didn’t see. PATTERN Approve before commit Surface tool calls before execution. Let the user say no. 54 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
55. Resources AG-UI Protocol DOCS docs.ag-ui.com Specification, events, transports, integration guides. SOURCE github.com/ag-ui- protocol/ag-ui Reference implementations, examples, framework adapters. PLAYGROUND dojo.ag-ui.com Live demos — see streaming, state sync, and HITL in action. 55 MCP, A2A, and AG-UI: The Agentic Protocol Stack Building Composable AI Systems
56. It’s a wrap, thank you! thinktecture.com max.marschall@thinktecture.com Slides: thinktecture.com/max-marschall — any questions?