MCP Apps: Extending servers with interactive user interfaces

by

Today we are introducing the MCP Apps Extension (SEP-1865) to standardize support for interactive user interfaces in the Model Context Protocol.

This extension addresses one of the most requested features from the MCP community and is based on the proven work of MCP-UI and OpenAI Apps SDK – Ability of MCP Server to provide interactive user interface to hosts,

The MCP Apps extension introduces a standardized pattern for declaring UI resources, connecting them to tools, and enabling bidirectional communication between the embedded interface and the host application.

Example of inline chat app with interactive UI for permission management

The SEP was written by MCP core maintainers at OpenAI and Anthropic in collaboration with MCP-UI creators and lead maintainers from the MCP UI Community Working Group.

Standardization for interactive interfaces#

Currently, MCPs are limited to exchanging text and structured data with server hosts. While this works well for many use cases, it creates friction when the tool needs to present visual information or gather complex user input.

For example, consider a data visualization MCP server that returns chart data as JSON. The host application must interpret and present that data. Handling all types of specific data in this scenario becomes a significant burden for client developers, who will need to create their own logic to render the UI. As more UI requirements emerge, such as the need to collect multiple related settings from users, the complexities increase. Alternatively, without UI support, these interactions become awkward exchanges of text prompts and responses.

The MCP community has been creative in working around these limitations, but different implementations using different conventions and architectures make it difficult for servers to work consistently across clients. This lack of standardization creates a real risk of ecosystem fragmentation – something we are actively working to prevent.

building together#

The MCP-UI project, created by Ido Salomon and Liad Yosef and run by a dedicated community, pioneered the approach of agentic apps with interactive interfaces. The project developed patterns to provide rich user interfaces as first-class MCP resources, proving that agentic apps fit naturally within the MCP architecture. The project is supported by a large community and provides a rich SDK, which has been adopted in major companies and projects such as Postman, Shopify, Hugging Face, Goose, and ElevenLabs.

The OpenAI Apps SDK further validates the demand for rich UI experiences within conversational AI interfaces. The SDK enables developers to build rich, interactive applications inside ChatGPT using MCP as its backbone. To ensure interoperability and establish consistent security and usage patterns across the ecosystem, Anthropic, OpenAI and MCP-UI are collaborating to create an official MCP extension for the interactive interface.

Example of a fullscreen app with a rich data table interface

MCP Apps Extension Specification#

We are proposing a specification for UI resources in MCP, but the implications go far beyond just a set of schema changes. The MCP Apps extension is beginning to look like an agentic app runtime: a foundation for novel interactions between AI models, users, and applications. The proposal is intentionally weak, starting with core patterns that we plan to expand on over time.

Key Design Decisions#

Pre-declared resources#

UI template resources ui:// URI scheme, referenced in tool metadata.

// Server registers UI resource
{
  uri: "ui://charts/bar-chart",
  name: "Bar Chart Viewer",
  mimeType: "text/html+mcp"
}

// Tool references it in metadata
{
  name: "visualize_data_as_bar_chart",
  description: "Plots some data as a bar chart",
  inputSchema: {
    type: "object",
    properties: {
      series: { type: "array", items: .... }
    }
  },
  _meta: {
    "ui/resourceUri": "ui://charts/bar-chart",
  }
}

This approach enables hosts to prefetch and review templates before tool execution, improving both performance and security. It separates the static presentation (the template) from the dynamic data (the tool results), enabling better caching.

MCP transport for communication#

Instead of inventing a custom messaging protocol, UI components communicate with hosts using the existing MCP JSON-RPC base protocol. postMessageThis means that:

  • UI developers can use the standard @modelcontextprotocol/sdk to create their app
  • All communications are structured and auditable
  • Future MCP features automatically work with UI extensions

Starting with HTML#

The initial extension specification only supports text/html Content presented in a sandboxed iframe. It provides:

  • universal browser support
  • Well understood security model
  • Screenshot and preview creation capabilities
  • A clear baseline for future expansion

Other content types such as external URLs, remote DOM, and native widgets have apparently been postponed to future iterations.

Safety-First#

Hosting interactive content from an MCP server requires careful security considerations. The proposal addresses this through several layers:

  1. iframe sandboxing: All UI content runs in a sandboxed iframe with restricted permissions
  2. predefined template:Hosts can review HTML content before rendering
  3. audio message: All UI-to-host communication happens via loggable JSON-RPC
  4. user consent:Host may require explicit approval for UI-initiated tool calls

These mitigations provide defense in depth against malicious servers while preserving the flexibility developers need.

backward compatibility#

MCP Apps is an optional extension. The existing implementation continues to work without changes, and hosts can gradually adopt UI support at their own pace. Servers should provide text-only fallbacks for all UI-enabled tools and return meaningful content even when the UI is unavailable, so they can serve both UI-enabled and text-only hosts.

What will happen next#

The UI Community Working Group has played a key role in shaping this proposal through extensive feedback and discussion. We have created an early access SDK to demonstrate the patterns and types described in the specification proposal. The MCP-UI client and server SDKs support these patterns.

If you are interested in contributing to this effort, we invite you to:

Gratitude#

This proposal would not exist without the work of the maintainers of MCP-UI, OpenAI, and Anthropic.

bird salomon And Liad YosefVia MCP-UI and Moderation #ui-wgIncubated and championed several patterns that MCP apps now standardize, and worked with contributors to demonstrate that UI resources could be a natural part of MCP.

shaun strong, olivier chafik, Anton PidkuikoAnd jerome swanack Anthropic was helpful in taking the initiative forward and taking the collaboration forward.

nick cooper, Alexey ChristakisAnd brian ashley OpenAI has provided valuable guidance from its experience in building apps SDKs.

special thanks to UI Community Action Group Members and all those who contributed to the discussions that shaped this proposal.



Leave a Comment