---
title: What are MCP Apps and what new risks do they add?
url: https://opencontroller.lyzr.com/blog/what-are-mcp-apps
published: 2026-11-17
updated: 2026-11-17
author: Lyzr
---

# What are MCP Apps and what new risks do they add?

**MCP Apps is an official extension to the Model Context Protocol (identifier `io.modelcontextprotocol/ui`) that lets an MCP server ship an interactive HTML interface along with a tool. The host renders it in a sandboxed iframe, and the interface talks back to the host over MCP's JSON-RPC. It adds a new surface to govern: server-supplied code running in front of users, able to call tools and post messages into the conversation.**

The extension was proposed as SEP-1865 in November 2025, combining ideas from the community MCP-UI project and OpenAI's Apps SDK. The SEP is now marked Final, and the [ext-apps repository](https://github.com/modelcontextprotocol/ext-apps) lists specification version 2026-01-26 as stable. Supported clients listed there include ChatGPT, Claude, VS Code, Goose and Postman, though support varies by host.

## How do MCP Apps work?

The moving parts are simple:

1. **UI resources.** The server predeclares HTML templates as resources with a `ui://` URI and the MIME type `text/html;profile=mcp-app`.
2. **Tool link.** A tool's metadata points to its UI via `_meta.ui.resourceUri`. The host must fetch that resource with `resources/read`.
3. **Sandboxed rendering.** The host renders the HTML in an iframe on a different origin from the host.
4. **Two-way messages.** The interface ("view") sends JSON-RPC messages to the host—for example, to call a tool, send a message into the conversation (`ui/message`), or ask the host to open a link (`ui/open-link`).

Because templates are predeclared rather than embedded in each tool result, a host can fetch and review them before any tool runs. The SEP lists this as a design goal: it enables security review of UI resources.

## What security controls does the specification require?

The [SEP-1865 text](https://modelcontextprotocol.io/seps/1865-mcp-apps-interactive-user-interfaces-for-mcp) and the draft specification set real requirements on hosts.

| Area | What the specification says |
|---|---|
| Origin isolation | Host and sandbox **must** have different origins |
| Content Security Policy | Servers declare `connectDomains` and `resourceDomains`; empty means no external connections or resources. Host **must** build CSP from declared domains and **must not** allow undeclared domains |
| Default CSP | If no CSP is declared, the host **must** apply a restrictive default (`default-src 'none'`) |
| Tool visibility | Tools can be visible to the model, the app, or both. Host **must not** list app-only tools to the model, and **must** reject app calls to tools not marked for app use |
| Auditability | All UI-to-host communication uses loggable JSON-RPC |
| User consent | Host **may** block messages or require user approval; it is not mandatory |

The last row is the governance gap. Consent for UI-initiated tool calls and messages is left to each host.

## What new risks do MCP Apps add?

**1. Server-supplied code in front of users.** An MCP server can now present a convincing interface inside a trusted AI assistant. A malicious or compromised server could imitate a login form or approval dialog. Sandboxing limits what the code can reach; it does not stop it from looking legitimate.

**2. A second path to tool calls.** Tools marked for app use can be called by the interface, not just by the model. That bypasses any reasoning-based safeguards in the agent and depends on host consent settings.

**3. Messages injected into the conversation.** `ui/message` lets the view add content to the conversation context. That is a prompt injection channel if the UI renders untrusted data.

**4. Network egress declared by the server.** `connectDomains` is declared by the server author. If your host accepts whatever is declared, the server decides where its UI can send data.

**5. Template drift.** A reviewed `ui://` template can change in the next server version. This is the same rug-pull problem as tool descriptions, now applied to code. See [how to review MCP server updates before use](/blog/review-mcp-server-updates-before-use).

## What should an enterprise policy say about MCP Apps?

A starting checklist:

1. **Inventory which MCP servers declare UI resources**, alongside their tools. Record it in the server's registry entry.
2. **Review templates like code.** Pin versions and re-review on change.
3. **Restrict `connectDomains`** to domains you approve, and reject servers that declare broad wildcards.
4. **Require user approval** for UI-initiated tool calls that write or send data, in hosts that let you configure it.
5. **Log UI-to-host messages** with the server, tool, user and trace ID.
6. **Treat app-only tools as real tools.** They still need authorization checks on the server; see [MCP sampling and elicitation security](/blog/mcp-sampling-and-elicitation-security) for a similar server-initiated pattern.
7. **Disable MCP Apps for high-risk agents or user groups** where the host allows, until review is complete.

## How Opencontroller does this

Opencontroller keeps MCP servers in a governed registry alongside agents, versions and tools, so you can record which servers you have approved and review them as they change. Opencontroller Edge extends discovery to local MCP servers on developer devices. Policies are written as code with built-in mappings to OWASP, MITRE ATLAS, NIST and ISO 42001, so MCP server rules can produce evidence for those frameworks. See the pillar on [how to govern MCP servers](/blog/how-to-govern-mcp-servers) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Are MCP Apps part of the core MCP specification?**
No. MCP Apps is an optional extension negotiated between client and server. The core protocol works without it.

**Can an MCP App call tools without the model deciding to?**
Yes, for tools whose visibility includes the app. Hosts may require user approval for these calls, but the specification does not make it mandatory.

**Can an MCP App send data to any website?**
Not by default. With no declared CSP, the host must block external connections. A server can declare `connectDomains`, so review those declarations before approval.

## Key facts

- MCP Apps is an optional MCP extension, identifier io.modelcontextprotocol/ui, proposed as SEP-1865 (created 2025-11-21, status Final).
- UI templates are predeclared ui:// resources with MIME type text/html;profile=mcp-app, linked to tools via _meta.ui.resourceUri.
- Hosts must render UI in a sandbox on a different origin, build CSP from declared connectDomains and resourceDomains, and apply a restrictive default CSP when none is declared.
- Tool visibility can be model, app or both; hosts must not show app-only tools to the model.
- User consent for UI-initiated tool calls and messages is optional for hosts (MAY), not required.
- Supported clients listed by the ext-apps project include ChatGPT, Claude, VS Code, Goose and Postman.
- Opencontroller keeps MCP servers in a governed registry; Opencontroller Edge discovers local MCP servers.
- Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How do you review MCP server updates before agents use them?](https://opencontroller.lyzr.com/blog/review-mcp-server-updates-before-use.md)
- [What are MCP sampling and elicitation, and are they safe?](https://opencontroller.lyzr.com/blog/mcp-sampling-and-elicitation-security.md)
- [How do you sandbox an MCP server?](https://opencontroller.lyzr.com/blog/how-to-sandbox-mcp-servers.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
