ORG
← Architecture Layers

AI Agent Protocols @ ORG

Six protocols that power agentic commerce — from tool access and agent discovery to payments, UI rendering, and real-time streaming. Mapped to MediaMarktSaturn's architecture with implementation guidance.

Based on Google's Developer's Guide to AI Agent Protocols ↗

The 6 Protocols

Click any card for deep-dive details, architecture mapping, and code examples

🔌
Model Context Protocol
MCP
● Ready — In Production
Standardizes how agents access tools & data. One connection pattern replaces hundreds of custom API integrations. Agents discover tools automatically.
Where @ ORG MCP GW (Cloudflare Workers) · MCP Agentic Commerce App (GKE) · BOS GraphQL · /.well-known discovery
Click for details →
🤝
Agent2Agent Protocol
A2A
◐ Planned
Standardizes agent-to-agent discovery via Agent Cards at well-known URLs. Agents find each other, learn capabilities, and communicate without custom integration.
Where @ ORG OneChat ↔ Sub-Agents · /.well-known/agent-card.json · Cross-domain agent federation
Click for details →
🛒
Universal Commerce Protocol
UCP
⊘ Blocked — Not Available in EU
Standardizes shopping lifecycle (catalog, checkout, orders) through typed schemas across any transport. Works via REST, MCP, or A2A.
Where @ ORG ⚠️ UCP not yet available in Europe. MCP Agentic Commerce App uses custom checkout flows via BOS/API GW today.
Click for details →
🔐
Agent Payments Protocol
AP2
◑ Exploring
Adds cryptographic payment mandates with guardrails: spending limits, merchant allowlists, and human-in-the-loop approval. Full audit trail for every transaction.
Where @ ORG Payment API authorization · AI Firewall policy enforcement · Checkout guardrails
Click for details →
🎨
Agent-to-User Interface
A2UI
◐ Planned
Agents compose UI layouts from 18 safe primitives (Card, Row, Text, Button, etc.). Structure separated from data — agents send a component tree + data payload.
Where @ ORG Chat UI product cards · Webshop inline recommendations · Dynamic agent response widgets
Click for details →
📡
Agent-User Interaction
AG-UI
◐ Planned
Standardizes SSE streaming between agent and frontend. Typed events (TEXT_MESSAGE_CONTENT, TOOL_CALL_START, etc.) — frontend doesn't care which framework produced them.
Where @ ORG Chat UI streaming responses · OneChat real-time updates · Tool call progress indicators
Click for details →

Protocol Stack

Which protocol operates at which layer of the ORG architecture

AG-UI Real-time SSE streaming to frontend Chat UI · Webshop
A2UI Declarative UI component rendering Chat UI · Mobile App
A2A Agent discovery & inter-agent communication OneChat Orchestration
MCP Tool & data access via standardized servers MCP GW · MCP Servers
UCP Standardized shopping lifecycle ⚠️ EU unavailable Commerce App · API GW
AP2 Payment mandates & audit trails Payment API · Firewall

🧭 When to Use Which Protocol

Practical decision guide — what each protocol does and where it fits in the ORG architecture

🔌
MCP — Model Context Protocol
Agent needs to access tools or data
  • Definition: Standardizes how agents discover and call tools. One protocol replaces hundreds of custom API integrations
  • Use when: An agent needs to search products, check stock, create orders, query databases, or call any backend API
  • Where at ORG: MCP Gateway (Cloudflare Workers) → MCP Agentic Commerce App (GKE) → BOS GraphQL → downstream APIs via Kong
  • How it works: MCP servers expose tools with JSON Schema definitions. Agents discover tools via /.well-known/mcp and call them without custom integration code
✅ In Production
Foundation protocol — every other protocol builds on top of MCP. If you're building an agent that needs data or actions, start here.
🤝
A2A — Agent-to-Agent Protocol
Agent needs to find and delegate to other agents
  • Definition: Standardizes agent discovery and inter-agent communication via Agent Cards at /.well-known/agent-card.json
  • Use when: An orchestrator agent needs to route requests to specialized agents (product search, stock checker, store finder) without hardcoded integrations
  • Where at ORG: OneChat orchestration discovers sub-agents at runtime. Adding a new agent capability = deploy agent + Agent Card — zero orchestrator changes
  • How it works: Each agent publishes a JSON card describing its capabilities and endpoint. Orchestrators fetch cards, match intents to capabilities, and delegate tasks
ADK RemoteA2aAgent
📡
AG-UI — Agent-User Interaction Protocol
Agent needs to stream responses to a frontend
  • Definition: Standardizes SSE streaming between agent backends and frontends. Typed events replace raw text streaming
  • Use when: Building a chat UI, showing tool call progress ("Searching products..."), or implementing human-in-the-loop approvals
  • Where at ORG: Chat UI connects to OneChat via AG-UI SSE stream. Users see real-time tool calls, partial results, and confirmation prompts
  • How it works: Backend emits typed events (TEXT_MESSAGE_CONTENT, TOOL_CALL_START, TOOL_CALL_RESULT, RUN_FINISHED). Frontend renders them — framework-agnostic
SSE Event Stream
🎨
A2UI — Agent-to-User Interface Protocol
Agent needs to render rich UI, not just text
  • Definition: Agents compose UI layouts from 18 safe primitives (Card, Row, Text, Button, Image, etc.). Structure is separated from data
  • Use when: Agent responses need product cards, comparison tables, order forms, or any structured visual output instead of plain text
  • Where at ORG: Chat UI renders A2UI component trees as interactive product cards, price comparisons, and checkout forms. Same tree renders on web (Lit) and mobile (Flutter)
  • How it works: Agent sends a flat component tree (IDs referencing each other) + a data payload. A renderer (Lit, Flutter, Angular) turns JSON into native UI
Component Tree + Data
🔐
AP2 — Agent Payments Protocol
Agent needs to handle money
  • Definition: Cryptographic payment mandates with guardrails — spending limits, merchant allowlists, human approval, and full audit trails
  • Use when: An agent initiates a purchase, processes a refund, or authorizes any financial transaction on behalf of a user
  • Where at ORG: AI Firewall enforces AP2 policies at the edge. Payment API validates mandates. Transactions over configured limits pause for human approval via Chat UI
  • How it works: IntentMandate (user sets guardrails) → PaymentMandate (agent creates bound authorization) → PaymentReceipt (closes audit trail). Non-repudiatable
Early Stage
🛒
UCP — Universal Commerce Protocol
Standardized shopping lifecycle (catalog → checkout → order)
  • Definition: Typed schemas for the full shopping lifecycle — catalog discovery, checkout sessions, and order completion — across any transport (REST, MCP, A2A)
  • Use when: You need a standardized checkout flow that works across multiple suppliers and payment processors
  • Where at ORG: ⚠️ Not yet available in EU. Currently, MCP Agentic Commerce App handles checkout via BOS/API GW with internal schemas designed to be UCP-compatible
  • How it works: Suppliers publish catalogs at /.well-known/ucp. Agents construct typed CheckoutCreateRequest objects. Standard HTTP for transactions
⚠️ EU Unavailable
ORG's internal checkout schemas mirror UCP patterns. Migration will be straightforward once EU support launches.

🔄 End-to-End Commerce Flow — All 6 Protocols in Action

sequenceDiagram
    actor User
    participant ChatUI as Chat UI
    participant AGUI as AG-UI Stream
    participant OneChat as OneChat
Orchestration
    participant Agent as Commerce
Agent (A2A)
    participant MCP as MCP Server
(Commerce App)
    participant BOS as BOS / API GW
    participant Payment as Payment API

    User->>ChatUI: "Find me a 65" OLED TV under €1500"

    rect rgba(244,114,182,0.08)
        Note over ChatUI,AGUI: AG-UI — Real-time Streaming
        ChatUI->>AGUI: Open SSE connection
        AGUI-->>ChatUI: RUN_STARTED
    end

    rect rgba(251,146,60,0.08)
        Note over OneChat,Agent: A2A — Agent Discovery
        AGUI->>OneChat: Route user intent
        OneChat->>OneChat: Discover agent cards
        OneChat->>Agent: Delegate to product search agent
    end

    rect rgba(52,211,153,0.08)
        Note over Agent,BOS: MCP — Tool & Data Access
        Agent->>MCP: call product_search tool
        MCP->>BOS: GraphQL query
        BOS-->>MCP: Product results
        MCP-->>Agent: Filtered OLED TVs
    end

    rect rgba(129,140,248,0.08)
        Note over AGUI,ChatUI: A2UI — Dynamic UI
        Agent-->>AGUI: TOOL_CALL_RESULT
        AGUI-->>ChatUI: Render product comparison cards
    end

    User->>ChatUI: "Order the LG C4 for €1299"

    rect rgba(96,165,250,0.08)
        Note over Agent,BOS: UCP — Checkout Flow
        Agent->>MCP: create_checkout(LG C4, €1299)
        MCP->>BOS: POST /checkout-sessions
        BOS-->>MCP: Checkout created
    end

    rect rgba(248,113,113,0.08)
        Note over MCP,Payment: AP2 — Payment Authorization
        MCP->>Payment: Create PaymentMandate
        Payment-->>MCP: Requires approval
        MCP-->>Agent: Request authorization
        Agent-->>ChatUI: "Approve €1299 payment?"
        User->>ChatUI: ✓ Approve
        ChatUI->>Agent: Mandate signed
        Agent->>MCP: complete_checkout
        MCP->>Payment: PaymentReceipt issued
    end

    AGUI-->>ChatUI: RUN_FINISHED
    ChatUI-->>User: "✅ Order confirmed! LG C4 — €1,299"