MCP Apps let an MCP server send back a small interactive interface, such as a chart, a form or a live status card, that the client draws right inside the chat. A tool points to a ui:// resource holding an HTML page. The host loads that page in a sandboxed iframe, passes it the tool's result, and lets it call the server's tools again when the user clicks something.
We build a remote MCP server whose tools place real phone calls, so "should the call show up as a live card in the chat?" is a question we've had to answer for ourselves. To answer it properly we built a small call-status app on the official SDK and ran it against the SDK's own host bridge. This guide covers what the extension is, how it works on the wire, which clients render it as of November 9, 2026, what we learned from building one, and when plain tool output is the better choice. DialMCP itself doesn't ship an MCP App today, and we explain why below.
What MCP Apps are
A normal tool returns text and, optionally, structured output. The model reads it and writes a reply. That works until the result is something a person wants to poke at: two hundred rows to filter, a map, a PDF with clauses to approve. Turning each click into a new prompt gets tedious fast.
MCP Apps is the official answer. It's specified as SEP-1865, "MCP Apps: Interactive User Interfaces for MCP," and its identifier is io.modelcontextprotocol/ui. It was proposed on November 21, 2025, and announced as live on January 26, 2026, as the first official MCP extension. The stable spec version is still 2026-01-26. A draft is under active development (its last commit was November 4, 2026), and features that exist only in the draft, like file downloads and tools registered by the app itself, aren't part of the stable contract yet.
Being an extension matters. MCP Apps aren't part of the core protocol, and nothing happens unless the client says it supports them. A server can ship a UI and still work everywhere else, because the spec is explicit: if the host doesn't support MCP Apps, "tool behaves as standard tool (text-only fallback)."
MCP-UI, the OpenAI Apps SDK and MCP Apps
Three names float around this topic, and they aren't rivals. MCP-UI is the community project, started by Ido Salomon and Liad Yosef, that first put interactive UI over MCP. The spec credits it with the two-way messaging model, and names Postman, Hugging Face, Shopify, Goose and ElevenLabs as early adopters. OpenAI's Apps SDK, introduced in preview in October 2025, came with its own way of showing widgets in ChatGPT. MCP Apps "unifies the approaches pioneered by MCP-UI and the Apps SDK," and OpenAI and Anthropic worked on it with the MCP-UI maintainers.
Where that leaves each one today:
- MCP-UI still exists. The MCP blog says it "isn't going anywhere," and its
@mcp-ui/*packages now implement the MCP Apps standard. Watch the versions, though:@mcp-ui/client7.1.1 still depends on ext-apps 1.x and the v1 TypeScript SDK. - OpenAI points new work at MCP Apps. Its docs, now filed under Plugins, tell you to declare
_meta.ui.resourceUriand use theui/*bridge.window.openaistays for compatibility and for ChatGPT-only extras such as checkout and file uploads. - New servers should start with the official SDK,
@modelcontextprotocol/ext-apps, since that's what hosts build against.
How MCP Apps work on the wire
There are four moving parts, and each one is small.
1. The client opts in. The client lists the extension in its capabilities, under extensions (at initialization up to the 2025-11-25 protocol; in each request's _meta under 2026-07-28), with the one MIME type it can render. The stable spec defines no matching server-side capability. A server that wants to behave differently for UI hosts reads the client's capabilities instead (the SDK's getUiCapability() helper does this).
"capabilities": {
"extensions": {
"io.modelcontextprotocol/ui": {
"mimeTypes": ["text/html;profile=mcp-app"]
}
}
}
2. The tool points at a UI resource. The tool definition carries _meta.ui.resourceUri. An older flat key, _meta["ui/resourceUri"], is deprecated, but the SDK still writes both so older hosts keep working.
3. The resource holds the HTML. It uses the ui:// scheme and must have the MIME type text/html;profile=mcp-app. Because it's declared up front rather than stuffed into a tool result, the host can fetch it, cache it and inspect it before anything runs. Resource-level _meta.ui can also declare which outside domains the page needs (csp.connectDomains, csp.resourceDomains, csp.frameDomains), device permissions it would like, a preference for a border, and a dedicated sandbox origin (domain).
4. The page talks to the host over postMessage. It's plain JSON-RPC 2.0, the same message format MCP already uses, so every exchange can be logged. Here's the stable method set:
| Message | Direction | What it does |
|---|---|---|
ui/initialize, then ui/notifications/initialized | View to host | Handshake. The host replies with its capabilities and context (theme, display mode) |
ui/notifications/tool-input | Host to view | The arguments the model called the tool with |
ui/notifications/tool-result | Host to view | The full tool result, including structuredContent |
tools/call | View to host | The page calls a tool on its own server, through the host |
ui/message, ui/update-model-context | View to host | Post a message into the chat, or quietly update what the model knows |
ui/open-link, ui/request-display-mode | View to host | Ask to open a URL, or to switch between inline, fullscreen and picture-in-picture |
ui/notifications/size-changed | View to host | Report the page's size so the host can fit the frame |
ui/resource-teardown | Host to view | Warn the page before the host removes it |
There's also tool-input-partial for streaming arguments, tool-cancelled, and host-context-changed for theme switches. You don't have to use the SDK in the page at all. The spec shows raw window.parent.postMessage calls, and the docs call the App class "a convenience wrapper, not a requirement."
One more field is worth knowing: _meta.ui.visibility on a tool. It takes "model", "app" or both (the default). An app-only tool, such as a Refresh button's backend, is hidden from the model but callable from the page. The host is the one that enforces this, a point we come back to below.
Which clients render MCP Apps
Support has spread quickly, but "listed somewhere" and "documented by the vendor" aren't the same thing. This is the state on November 9, 2026, with the kind of source behind each row.
| Client | Renders MCP Apps? | Source and notes |
|---|---|---|
| Claude (web and desktop) | Yes | Since launch day. Asks the user to Allow or Always allow before showing an app |
| Claude mobile | Yes, with limits | Claude's docs: renders in a native WebView, with no camera, microphone or location access. The connector has to be added on web or desktop first |
| Claude Code | No | Claude's quickstart says Claude Code "calls the tool as text and doesn't render the UI." Its own docs describe ui:// resources as pages for a host application to render |
| ChatGPT | Yes | OpenAI's changelog, February 22, 2026: "fully compatible with the MCP Apps spec" |
| VS Code (GitHub Copilot) | Yes, labelled experimental | Shipped in Insiders on January 26, then in 1.109. VS Code's MCP docs still say "MCP Apps (Experimental)" |
| Goose | Yes, labelled experimental | Goose Desktop. Its docs note it follows a draft spec |
| Microsoft 365 Copilot | Yes | Microsoft's docs. Not the same product as GitHub Copilot |
| Cursor | Yes | Cursor's changelog (2.6, March 2026), plus the community matrix |
| LibreChat | Opt-in | Off by default; enable with mcpSettings.apps: true |
| Codex, Gemini CLI | Not that we could find | No vendor documentation of rendering. OpenAI's own guidance says to keep tools useful without UI so Codex can finish the job |
The official extension matrix also checks Postman, MCPJam, Archestra.AI, PostHog Code, Kiro Crew and Glean, but it says plainly that "this list is maintained by the community." Treat it as a lead and test in the client you care about.
What Claude adds on top of the spec
If Claude is your main target, its developer docs add a few details the spec leaves to hosts:
- A stable sandbox origin is opt-in. If your page runs its own OAuth flow or has a CORS allowlist, set
ui.domainto the first 32 hex characters of the SHA-256 of your full connector URL, followed by.claudemcpcontent.com. Scheme, path and trailing slash all change the hash. Local stdio servers can't use it. - Very large results never reach the page. When the code-execution sandbox is on, results over about 150,000 characters get written to the sandbox's file system instead, and the app never loads its data.
- Inline cards should stay small. The design guidelines suggest at most two actions and four or five data points inline, with fullscreen for anything bigger.
- Directory listings need screenshots. An MCP App submitted to the connectors directory needs three to five PNG screenshots of the app in a response.
For adding a remote server to Claude in the first place, see how to add an MCP server to Claude.
Building one: a call-status card, tested
Our test case was the obvious one for us: a card that shows a phone call's status, with a Refresh button. It used @modelcontextprotocol/ext-apps 2.0.4 (npm's latest tag on November 9) with the v2 TypeScript packages, @modelcontextprotocol/server and client 2.4.0. The call data was a stub, not our production server.
First, pick your major version, because the two lines don't mix. ext-apps 2.x needs the split v2 SDK packages and zod 4.2 or later. ext-apps 1.x pairs with the older single @modelcontextprotocol/sdk package. Claude's own quickstart still uses 1.7.5 with SDK v1. The 2.0 release notes say the wire protocol didn't change, so 2.x pages run in 1.x hosts and the other way around.
The server registers two tools and one resource:
import { McpServer } from "@modelcontextprotocol/server";
import { registerAppTool, registerAppResource, RESOURCE_MIME_TYPE }
from "@modelcontextprotocol/ext-apps/server";
import { z } from "zod";
const VIEW_URI = "ui://calls/status.html";
registerAppTool(server, "show_call", {
title: "Show call status",
description: "Show the live status of a phone call by id.",
inputSchema: z.object({ call_id: z.string() }),
_meta: { ui: { resourceUri: VIEW_URI } },
}, async ({ call_id }) => {
const c = await getCall(call_id);
return {
content: [{ type: "text", text: `Call ${c.id} to ${c.to}: ${c.status} (${c.step})` }],
structuredContent: c,
};
});
// Backs the Refresh button. Hidden from the model.
registerAppTool(server, "refresh_call", {
description: "Re-read a call's status.",
inputSchema: z.object({ call_id: z.string() }),
_meta: { ui: { resourceUri: VIEW_URI, visibility: ["app"] } },
}, async ({ call_id }) => {
const c = await getCall(call_id);
return { content: [{ type: "text", text: `${c.status}: ${c.step}` }], structuredContent: c };
});
registerAppResource(server, "Call status view", VIEW_URI, {}, async () => ({
contents: [{ uri: VIEW_URI, mimeType: RESOURCE_MIME_TYPE, text: html }],
}));
Notice the text in content. That's what a client without UI support shows, and the spec says tools "MUST return meaningful content array even when UI is available." The page reads structuredContent. Here's its script, bundled with esbuild and inlined into the HTML:
import { App } from "@modelcontextprotocol/ext-apps";
const app = new App({ name: "Call status", version: "0.1.0" });
let callId;
const draw = ({ structuredContent: c }) => {
callId = c.id;
document.getElementById("status").textContent = c.status;
document.getElementById("step").textContent = c.step;
document.getElementById("refresh").disabled = c.status === "completed";
};
app.ontoolresult = draw; // set handlers before connect()
document.getElementById("refresh").onclick = async () =>
draw(await app.callServerTool({ name: "refresh_call", arguments: { call_id: callId } }));
await app.connect();
To exercise the page without hosting anything publicly, we loaded it in headless Chromium inside a test page built on the SDK's AppBridge, fed it real results captured from the server, and logged every message. It's a test harness, not a spec-compliant host: a real web host also needs a separate-origin sandbox, covered in the next section. The page did exactly what the spec describes:
view-> ui/initialize
host-> (result: host capabilities + context)
view-> ui/notifications/initialized
host-> ui/notifications/tool-input
host-> ui/notifications/tool-result # card shows "in_progress, On hold (IVR: billing)"
view-> ui/notifications/size-changed
view-> tools/call refresh_call # user clicks Refresh
host-> (result) # card shows "completed", button disables
Five things surprised us or are easy to miss:
- The page is heavier than you'd guess. Our one-file view, with the SDK bundled in, came to about 665 KB of minified JavaScript (about 147 KB gzipped). The SDK's prebuilt
app-with-deps.jsalone is about 542 KB. Claude's quickstart loads it from a CDN instead, which means declaring that CDN incsp.resourceDomains. - App-only tools still show up in
tools/list. Ourrefresh_callcame back to every client withvisibility: ["app"]on it. Hiding it from the model is the host's job, so don't put anything behind visibility that would be unsafe for a model to call. Check authorization on the server. - The server doesn't adapt by itself. A client that didn't declare the extension got the same tool list, the same
_meta, and could still read the resource. If you want a different tool set for text-only clients, checkgetUiCapability()and register variants. - Both tool metadata keys are on the wire.
registerAppToolwrote_meta.ui.resourceUriand the deprecatedui/resourceUri. - Our v2 client negotiated protocol 2025-11-25 and carried the extension in the normal
initializecapabilities. We didn't test the 2026-07-28 revision, which drops that handshake and sends client capabilities in each request's_metainstead.
If you write servers in Python, there's no official ext-apps Python package. The repo's qr-server and say-server examples use the regular Python SDK on the server side, while the page is still JavaScript. FastMCP also documents its own MCP Apps support. Our FastMCP guide covers the framework itself.
The security model
An MCP App is third-party code running inside someone else's chat window, so most of the spec is about containment. In the stable version:
- Views are sandboxed. Web hosts run each view in a sandboxed iframe on a different origin from the host, and native apps such as Claude mobile use a web view instead. The overview says this stops the page from reading the host's DOM, cookies or local storage, or navigating the parent page.
- The default CSP blocks the network. If a resource declares nothing, the host must apply a policy with
connect-src 'none', plus scripts and styles only inline or from the page's own origin. Hosts must not allow domains the resource didn't declare. - Hosts mediate every call. A tool call from the page goes through the host, which may block it or ask the user first. That consent step is a MAY, not a MUST, so don't count on it. LibreChat, for one, does prompt ("Run tool from app?").
- The page sees what the host passes it, meaning the tool input, the tool result and host context. It doesn't get the rest of the conversation.
None of this changes the server-side rules. An App doesn't make a destructive tool safer, and a button that calls one is still a call you need to authorize. Our MCP security checklist applies unchanged.
When plain tool output is enough
Most tools shouldn't have a UI. MCP's own overview lists what an App buys you (staying in the conversation, two-way data flow with the host, the host's sandbox) and says that if your use case doesn't benefit from those properties, "a regular web app might be simpler." Here's how we'd decide:
| Situation | Better fit |
|---|---|
| The user explores or edits the result: filters, maps, diagrams, forms with dependent fields | MCP App |
| The model needs to see what the user did in the UI | MCP App (ui/update-model-context) |
| The result is a fact or a short summary the model passes on | Text plus structured content |
| Your users are mostly in Claude Code, Codex or another client that doesn't render apps | Text, maybe with a link |
| The UI needs live audio, long sessions, or should keep working after the chat closes | A normal web page, linked from the result |
DialMCP sits in the last two rows. Our tools return one text block of JSON that any client can read. place_call and get_call also return a listen_url, a signed web page meant only for the person who placed the call. While the call runs, it streams the live audio and transcript and has a stop button. Afterwards it shows the recording and transcript. A link works in every client we support, including the terminal ones. Live call audio would need a host to allow streaming media from our domain. And a page in its own tab doesn't disappear when the chat scrolls on. A status card like the one we tested would be a nice extra in Claude or ChatGPT, but it wouldn't replace the link. Long calls also raise the question of how results arrive, which is what the MCP Tasks extension is for.
MCP Apps examples worth reading
The fastest way to learn the patterns is the examples folder in the ext-apps repo. It has 26 entries as of November 9. Grouped by what they teach:
- Starter templates:
quickstartandbasic-server-*in vanilla JS, React, Vue, Svelte, Solid and Preact. - Data views:
cohort-heatmap-server,customer-segmentation-server,budget-allocator-server,scenario-modeler-server,system-monitor-server. - Media and documents:
pdf-server,video-resource-server,sheet-music-server,transcript-server. - Graphics:
map-server(a 3D globe),threejs-server,shadertoy-server. - Plumbing:
basic-host(a minimal host),lazy-auth-server,debug-server,integration-server. - Python servers:
qr-serverandsay-server.
The Node examples are published as @modelcontextprotocol/server-<name>, so you can run one over stdio with npx and add it to Claude Desktop to see it render. The Excalidraw whiteboard in the official demo GIF isn't in that folder, by the way; it's a separate project. For servers grouped by pattern rather than by UI, see our MCP server examples.
Further reading
- MCP Apps overview on modelcontextprotocol.io
- SEP-1865: the stable 2026-01-26 specification
- modelcontextprotocol/ext-apps on GitHub
- MCP blog: MCP Apps launch post
- Claude docs: add an interactive UI to your MCP server
- OpenAI docs: UI in ChatGPT
- MCP extension support matrix
Try a remote MCP server that does real work. DialMCP lets Claude, ChatGPT, Codex, Cursor or VS Code place real phone calls from your own verified number and hand back a transcript and a structured outcome. Add https://mcp.dialmcp.com/mcp as a connector and sign in. US and Canada, free during launch.
FAQ
What are MCP Apps?
MCP Apps are an official extension to the Model Context Protocol, io.modelcontextprotocol/ui, that lets a server return an interactive HTML interface along with a tool result. The tool points to a ui:// resource, the host renders that page in a sandboxed iframe, and the page and host exchange JSON-RPC messages over postMessage, so the page can show the result and call the server's tools again.
Are MCP Apps part of the MCP specification?
They're an optional extension, not part of the core protocol. The extension is specified in SEP-1865, its stable version is 2026-01-26, and a draft version is in development. A client has to declare support in its capabilities before a host renders anything, and tools still work as plain tools in clients that don't.
What is the difference between MCP-UI and MCP Apps?
MCP-UI is the community project that first put interactive UI over MCP, and its ideas fed into the standard. MCP Apps is the official standard that unified MCP-UI's approach with OpenAI's Apps SDK. MCP-UI's packages now implement MCP Apps, and the MCP maintainers have said MCP-UI isn't going away. For a new server, start with the official @modelcontextprotocol/ext-apps SDK.
Does Claude Code support MCP Apps?
No. As of November 9, 2026, Claude's own quickstart says Claude Code calls a UI-enabled tool as text and doesn't render the interface, and the Claude Code docs describe ui:// resources as pages for a host application to render. Claude on the web and in the desktop app does render MCP Apps, after the user allows it.
What happens if a client doesn't support MCP Apps?
The tool behaves like any other tool. The spec calls this a text-only fallback and requires UI-enabled tools to return a meaningful content array anyway, so the model can still read and use the result. If you want a different set of tools for text-only clients, check the client's capabilities with the SDK's getUiCapability helper.
Can I build an MCP App in Python?
Yes, for the server side. There's no official ext-apps Python package, but the official qr-server and say-server examples run on the regular Python MCP SDK, and FastMCP documents its own MCP Apps support. The page itself is still HTML and JavaScript, usually built with the ext-apps client library.