MCP Apps vs A2UI: Which Agent UI Standard Should You Use? (October 2026)

MCP Apps run developer-built web UI in a host; A2UI renders approved component descriptions in a client.
MCP Apps let developers ship coded web apps that agents can invoke inside conversations. A2UI lets a client render declarative UI from an approved component catalog. An agent may generate that UI at runtime, or a server may provide a fixed template. Both options can use MCP tools, which makes the choice less obvious than the names suggest.
The key decision is who renders the interface. With MCP Apps, a compatible host runs your web resource in an isolated view. With A2UI, your client renders approved components from JSON. That choice changes how you ship layouts, route actions, test behavior, and handle unsupported clients.
TL;DR
Choose MCP Apps when your product owns an interactive web UI inside a compatible AI host. Choose A2UI when your client owns the renderer and component catalog, especially for native or generated layouts. MCP can carry A2UI JSON, and either UI can be nested inside the other when your client supports the needed bridge.
What MCP Apps Are
MCP Apps are interactive applications attached to MCP tools. A tool definition points to a ui:// resource through _meta.ui.resourceUri. The host can fetch that resource before or after calling the tool, render it in an isolated iframe, and pass tool input and results to the view.
That gives you a familiar app architecture:
- The MCP server owns tools, auth, validation, side effects, and structured output.
- The resource owns UI, client state, layout, and user interaction.
- The host owns conversation placement, permissions, display modes, and app lifecycle.
- The bridge moves tool data, app state, host context, and tool calls between the iframe and the host.
This is the right shape when you want predictable product behavior. A billing app can show invoice tables and approval controls. A design app can open a canvas review screen. A project management app can display tasks, owners, due dates, filters, and edits. The agent decides when to call the tool, but your team still owns what the user sees and what actions are allowed.
The official MCP Apps docs describe the core model: MCP tools declare UI resources with ui:// URIs, hosts render those resources in iframes, and app-host communication flows through JSON-RPC over postMessage. The client support matrix tracks current host support because app UI support is more specific than basic MCP tool support.
In practice, MCP Apps are the portable base behind ChatGPT Apps, interactive Claude Connectors, IDE surfaces, and other MCP host experiences. If you are trying to build one app that can run across hosts, start with the MCP Apps contract and add host-specific capabilities only where they help.
What A2UI Is
A2UI, short for Agent to User Interface, is a declarative protocol for describing interfaces as data. You define the component catalog the client can render. An agent can produce JSON for that catalog, or a server can return a known A2UI layout and update its data later. The client validates the messages and maps them to its own components.
That gives you a different architecture:
- Your application defines the component catalog, schemas, renderer, and safety rules.
- An agent or server supplies a component tree and data updates.
- The client validates the JSON before rendering.
- The renderer maps the declarative UI to React, Flutter, Lit, Angular, or another UI layer.
This is useful when the right UI is not known ahead of time. A data agent might choose a table for raw rows, a chart for trends, cards for entities, or a short form for missing inputs. The same format also works for a fixed form served as an MCP resource. In either case, the client needs an A2UI renderer and a catalog that both sides understand.
The A2UI site lists v0.9.1 as its current production release and v1.0 as a candidate. Its A2UI over MCP guide uses application/a2ui+json for UI payloads and a2ui:// resource URIs. Those are different from an MCP App’s HTML resource and ui:// URI. A client that only renders MCP Apps will not automatically render an A2UI payload.
Side by Side
| MCP Apps | A2UI | |
|---|---|---|
| Best for | Product integrations, workflows, tools, dashboards, editors, approvals | Native cards, charts, forms, summaries, and dynamic data views |
| Who controls the UI? | Developer-owned web code | Client catalog constrains server- or agent-supplied JSON |
| What you ship | MCP server, tools, resources, bundled web app, tests | Component catalog, schema, renderer, validation rules, and optional agent instructions |
| When UI is created | App code ships with a release; tool data arrives at runtime | A layout may be fixed or generated at runtime |
| Runtime surface | Compatible host renders an isolated web view | A2UI-capable client renders validated declarative UI |
| State model | App state can sync through the host bridge | State depends on renderer and client integration |
| Security model | iframe sandbox, CSP, resource metadata, host bridge permissions | no arbitrary code execution, component allowlists, schema validation |
| Main risk | Host differences, iframe constraints, tool-result contract drift | Unsupported components, invalid JSON, unauthorized actions, and poor generated layouts |
| Testing focus | tool contracts, structuredContent, resources, display modes, host bridge, visual regressions | schema validity, renderer parity, component coverage, rejection and fallback paths |
| Good hybrid | App bundles an A2UI renderer for selected panels | A2UI client embeds an MCP App for a complex module |
When to Use MCP Apps
Use MCP Apps when you are building a tool that users will rely on across sessions, accounts, and real product data. The fact that the UI appears inside an AI conversation does not make it disposable. If the user can approve spending, edit production data, submit a ticket, compare records, review a generated design, or commit a workflow step, you probably want developer-owned code.
MCP Apps are a good fit for:
- product integrations that need auth, permissions, and account state
- dashboards where users sort, filter, inspect, and drill into data
- approval screens for code, content, policies, purchases, or operations
- editors where users change structured records, documents, queries, or designs
- workflows where the user alternates between chat and a stable app surface
- cross-host apps that should work in ChatGPT, Claude, and future MCP hosts
The tradeoff is ordinary app work. You write code. You maintain it. You test it. You handle host differences around display modes, viewport constraints, CSP, auth, state, and mobile behavior.
That tradeoff is usually worth it for a product integration because it gives you a real release process. You can review code, run tests, preserve accessibility, pin behavior, and ship changes intentionally. The model can still help the user, but the app does not depend on the model inventing the interface correctly every time.
If you are building this kind of app, sunpeak gives you the local loop: an MCP server, file-based resources and tools, a local MCP App Inspector that replicates ChatGPT and Claude-style runtimes, simulation fixtures, and a testing framework for unit, E2E, visual, and live-host tests.
npx sunpeak new sunpeak-app
cd sunpeak-app
pnpm dev
That starts the local development server and inspector, so you can test app UI without burning host credits or manually redeploying to a live account.
When to Use A2UI
Use A2UI when your product controls the client renderer and wants interface descriptions to travel as data. The agent may choose a layout for each answer, or the server may return a fixed component tree with changing values. Both cases require the client to support the catalog and its actions.
A2UI is a good fit for:
- data exploration where the agent chooses charts, tables, cards, or summaries
- internal tools where you control the client and can define the whole catalog
- generated reports where each answer might need a different layout
- form-like interactions where the agent can request missing fields through known components
- cross-platform agent clients that want the same declarative UI to render on web and mobile
The tradeoff is renderer work. You own the catalog, native components, action routing, validation, and fallback behavior. If an agent generates the composition, you also need clear component descriptions and test cases for malformed or unsupported output.
A2UI is strongest when the component catalog is small enough for the agent to use well. If you give the agent 80 loosely described components, it may choose odd combinations. If you give it a tight catalog with clear props, examples, and validation errors it can recover from, the generated UI becomes more reliable.
When to Use Both
The A2UI and MCP Apps guide describes three distinct arrangements. Pick one based on which client you control and which renderer it has:
- With A2UI over MCP, an MCP resource or tool result carries
application/a2ui+json, often under ana2ui://URI. The client must recognize that MIME type and render the declared catalog. A static resource can hold the layout while a tool result sendsupdateDataModelvalues. This uses MCP transport without requiring an MCP App iframe. - To place an MCP App inside A2UI, your A2UI client defines a custom component that embeds the app in an iframe. The client must provide the MCP App bridge and route the app’s tool calls and selected state changes. Use this when most of the screen should use native components, while one module needs developer-written web code.
- To place A2UI inside an MCP App, the app bundles an A2UI renderer in its iframe. It can call a server tool for A2UI JSON, validate it, and render a generated panel beside coded controls. This works when the outer host supports MCP Apps but has no native A2UI renderer.
For example, a sales operations MCP App could own account lookup, permissions, and update actions while an A2UI panel chooses a chart or summary table. The app must still validate the returned catalog IDs and action names, then show a text or fixed-layout fallback when the JSON cannot render. The A2UI in MCP Apps guide walks through that arrangement.
Before building a hybrid, write down which layer renders the UI, which layer authorizes each action, and how an unsupported payload falls back. Those three answers determine whether the integration remains usable in a host that only supports one of the formats.
Decision Framework
Ask these questions before choosing:
| Question | Choose MCP Apps when… | Choose A2UI when… |
|---|---|---|
| Who renders the interface? | a compatible AI host renders your web app | your client renders a known component catalog |
| Who builds the layout? | developers ship the app code | a developer or agent supplies component JSON |
| How do actions run? | the app requests host-mediated tool calls | the client validates and routes declared actions |
| Where does it run? | inside ChatGPT, Claude, or another MCP App host | inside an A2UI-capable client you control |
| How much UI variety is needed? | workflows and screens are known | layouts or data vary within an approved catalog |
| What happens on unsupported UI? | server provides a usable text tool result | client shows text or another approved component |
For an external integration into an MCP App host, start with the MCP Apps contract and keep the tool useful as text if UI support is absent. If you own the agent client and want native components, try A2UI with a small catalog first. Combine them only when you can test the bridge, renderer, and fallback at the boundary you chose.
Security and Testing
MCP Apps and A2UI both exist because raw agent output is not enough for serious workflows. They just put the safety boundary in different places.
MCP Apps isolate app code from the host page. You still need to configure resource metadata, CSP, allowed domains, tool annotations, auth, and state sync. You also need tests that cover the server-to-host-to-iframe chain because many bugs appear at those boundaries. A React component test cannot tell you whether the host can load the resource, whether display mode resizing works, or whether the model receives the right structuredContent.
A2UI renders JSON through known components instead of executing agent-supplied UI code. That reduces one class of risk, but action names and data still need checks. Reject unknown components and catalog versions, handle missing props, cap expensive render paths, test accessibility, and make the agent recover when the client rejects a layout.
Test the failure path as deliberately as the successful view. For MCP Apps, call the tool in a client without UI support and confirm the text result still makes sense; then test resource loading, bridge permissions, and denied actions in an inspector. For A2UI, feed the renderer an unknown catalog ID, malformed JSON, an unsupported component, and an unapproved action. Each should fail safely and leave the user with a usable fallback. The sunpeak testing overview covers protocol and inspector checks for the MCP App side.
In both cases, do not treat generated content as trusted. Validate tool input, keep sensitive display-only data out of model-visible structuredContent, and require authorization or confirmation for actions that change user data.
A Practical Choice
The fastest way to choose is to identify the renderer you can rely on. A compatible AI host can render an MCP App’s HTML resource and bridge. An A2UI client needs a catalog and renderer that understand the payload version. MCP is a possible transport for either, but transport support alone does not provide UI support.
If you are bringing a product into ChatGPT, Claude, or another MCP App host, build the MCP App and test it like product software. If you own an agent client and want it to present native views, build an A2UI catalog and renderer. Use a hybrid when one part of the workflow needs capabilities the outer renderer does not provide.
For MCP App development, the hard part is not writing a React component. It is proving that the tool result, resource metadata, iframe, bridge, display modes, state, and host differences all work together. That is the part sunpeak is built to handle locally and in CI.
Sources:
Get Started
npx sunpeak newFurther Reading
- What Is an MCP App? - architecture, hosts, and build path
- sunpeak is MCP-App-First - why the portable standard matters
- How to Build an MCP App - architecture for cross-host interactive UI
- Building One MCP App for ChatGPT and Claude - portability guide
- MCP App Capability Detection - host features and fallbacks
- MCP App UI resources, MIME types, and tool links
- MCP App host implementation guide
- MCP App Framework - build portable ChatGPT Apps and Claude Connectors
- MCP App Inspector - test app UI locally
- Testing Framework - automated MCP App tests
- MCP Apps Overview - official Model Context Protocol docs
- MCP Apps Client Matrix - current host support
- A2UI - protocol docs and current releases
- A2UI and MCP Apps - Google guide to combining the patterns
- A2UI over MCP implementation guide
- A2UI inside MCP Apps implementation guide
- A2UI GitHub - reference renderers and examples
Frequently Asked Questions
What is the difference between MCP Apps and A2UI?
MCP Apps link MCP tools to developer-built HTML resources that a compatible host renders in an isolated iframe. A2UI sends declarative JSON describing components from an approved catalog, which an A2UI-capable client renders with its own UI components. A2UI layouts may be fixed templates or generated at runtime, and A2UI can travel over MCP without becoming an MCP App.
Should I use MCP Apps or A2UI for a product integration?
Use MCP Apps when you need to ship developer-owned web UI into a compatible AI host. Use A2UI when you control the client renderer and want to show fixed or generated layouts through an approved component catalog. Choose by renderer support and action ownership, then test a text fallback for clients that cannot render the UI.
Can MCP Apps and A2UI work together?
Yes. A server can deliver A2UI JSON over MCP to a client with an A2UI renderer. An A2UI client can embed an MCP App through a custom iframe component. An MCP App can also bundle an A2UI renderer inside its iframe and request JSON from a server tool. Each path requires its own capability checks, validation, and fallback.
Which is more secure: MCP Apps or A2UI?
They control different risks. MCP Apps isolate developer-written web code in an iframe with host-enforced permissions, CSP, and a bridge. A2UI constrains generated layouts to components and actions accepted by the client catalog. Neither removes the need to validate tool input, authorize actions, handle untrusted data, and test the host or renderer.
Can I use A2UI inside ChatGPT Apps or Claude Connectors?
Yes, if the outer host supports MCP Apps and your app bundles an A2UI renderer. The iframe can request A2UI JSON from an MCP tool and render a fixed or generated panel inside its own UI. Validate the payload and catalog, authorize actions, and provide an accessible fallback.
What version of A2UI is current in October 2026?
The A2UI project lists v0.9.1 as its current production release and v1.0 as a candidate in October 2026. Check the renderer and catalog version before using examples because v0.8, v0.9, v0.9.1, and v1.0 materials coexist in the documentation.
How does sunpeak help with MCP Apps?
sunpeak is an open-source MCP App framework and testing framework. It gives developers a local inspector that replicates ChatGPT and Claude-style MCP App runtimes, a project structure for tools and resources, typed React APIs, simulation fixtures, and automated unit, E2E, visual, and live-host tests.
What should I test when comparing MCP Apps and A2UI?
For MCP Apps, test the tool contract, structuredContent, resource metadata, iframe rendering, host bridge, display modes, themes, auth, and app state. For A2UI, test schema validity, component allowlists, renderer behavior, unsupported components, accessibility, and how the agent recovers when the client rejects generated UI.