Today we’re introducing the proposal for 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 builds on proven work from MCP-UI and OpenAI Apps SDK - the ability for MCP servers to deliver interactive user interfaces to hosts.
MCP Apps Extension introduces a standardized pattern for declaring UI resources, linking them to tools, and enabling bidirectional communication between embedded interfaces and the host application.
The SEP was authored by MCP Core Maintainers at OpenAI and Anthropic, together with the MCP-UI creators and lead maintainers of the MCP UI Community Working Group.
Standardization for interactive interfaces
Currently, MCP servers are limited to exchanging text and structured data with hosts. While this works well for many use cases, it creates friction when tools need 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 that data and render it. Handling all kinds of specialized data in this scenario translates to a significant burden for client developers, who would need to build their own logic to render the UI. As more UI requirements come up, like the need to collect multiple related settings from users, the complexity balloons. 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 varying conventions and architectures make it harder for servers to work consistently across clients. This lack of standardization creates a real risk of ecosystem fragmentation - something we’re working to proactively prevent.
Building together
The MCP-UI project, created by Ido Salomon and Liad Yosef and maintained by a dedicated community, spearheaded the vision of agentic apps with interactive interfaces. The project developed patterns for delivering rich user interfaces as first-class MCP resources, proving that agentic apps fit naturally within the MCP architecture. The project is backed by a large community and provides rich SDKs, adopted at leading companies and projects such as Postman, Shopify, Hugging Face, Goose, and ElevenLabs.
The OpenAI Apps SDK further validated 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 interactive interfaces.
MCP Apps Extension specification
We’re proposing a specification for UI resources in MCP, but the implications go further than just a set of schema changes. The MCP Apps Extension is starting to look like an agentic app runtime: a foundation for novel interactions between AI models, users, and applications. The proposal is intentionally lean, starting with core patterns that we plan on expanding over time.
Key design decisions
Pre-declared resources
UI templates are resources with the 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 also separates static presentation (the template) from dynamic data (tool results), enabling better caching.
MCP transport for communication
Instead of inventing a custom message protocol, UI components communicate with hosts using existing MCP JSON-RPC base protocol over postMessage. This means that:
- UI developers can use the standard
@modelcontextprotocol/sdkto build their applications - All communication is structured and auditable
- Future MCP features automatically work with the UI extension
Starting with HTML
The initial extension specification supports only text/html content, rendered in sandboxed iframes. This provides:
- Universal browser support
- Well-understood security model
- Screenshot and preview generation capabilities
- A clear baseline for future extensions
Other content types such as external URLs, remote DOM, and native widgets are explicitly deferred to future iterations.
Security-first
Hosting interactive content from MCP servers requires careful security consideration. The proposal addresses this through multiple layers:
- Iframe sandboxing: All UI content runs in sandboxed iframes with restricted permissions
- Predeclared templates: Hosts can review HTML content before rendering
- Auditable messages: All UI-to-host communication goes through loggable JSON-RPC
- User consent: Hosts can require explicit approval for UI-initiated tool calls
These mitigations create defense in depth against malicious servers while preserving the flexibility developers need.
Backward compatibility
MCP Apps is an optional extension. Existing implementations continue working without changes, and hosts can gradually adopt UI support at their own pace. Servers should provide text-only fallback for all UI-enabled tools and return meaningful content even when UI is unavailable, so they can serve both UI-capable and text-only hosts.
What’s next
The UI Community Working Group has been instrumental in shaping this proposal through extensive feedback and discussion. We have built 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:
Acknowledgements
This proposal wouldn’t exist without the work of the maintainers at MCP-UI, OpenAI, and Anthropic.
Ido Salomon and Liad Yosef, through MCP-UI and moderation of #ui-wg, incubated and championed many of the patterns that MCP Apps now standardizes, and together with contributors demonstrated that UI resources can be a natural part of MCP.
Sean Strong, Olivier Chafik, Anton Pidkuiko, and Jerome Swannack from Anthropic helped steer the initiative and drive the collaboration.
Nick Cooper, Alexei Christakis, and Bryan Ashley from OpenAI have provided valuable direction from their experience building the Apps SDK.
Special thanks to the UI Community Working Group members and everyone who contributed to the discussions that shaped this proposal.