AI Engineer World's Fair 2026

MCP Apps: Extending the Frontier — Ido Salomon & Liad Yosef

Ido Salomon· Co-creator, MCP AppsLiad Yosef· Co-creator, MCP Apps18:38

Loading slides…

Read the talk

MCP Apps: Extending the Frontier

MCP Apps lets services deliver recognizable interfaces inside an assistant, while the host coordinates interactions, tool calls, and the wider user journey.

From a talk by Ido Salomon and Liad Yosef

Before you start: Familiarity with MCP tools and resources, basic web interfaces, and TypeScript will help you follow the implementation discussion.

Why should a service become a wall of text?

Why should connecting a service to an assistant mean giving up the interface that makes the service useful? Ido Salomon and Liad Yosef approach that question as co-creators and maintainers of MCP Apps. Salomon introduces himself as the creator of MCP-UI, an MCP steering committee member, and the creator of AtomCraft. Yosef works with him on MCP-UI and introduces AURA, a research lab he recently co-founded to explore the agentic web. They point to ChatGPT, VS Code, and Slack as places where this shift toward embedded applications is already happening.

Text is the natural input to a chat, but it is often a poor output format for information that already has a carefully designed interface. A service connected through MCP can return accurate data and still lose its navigation, visual hierarchy, and identity. Yosef describes companies’ reluctance to become textual databases: they have invested in making their products understandable, and a wall of text discards much of that work.

The alternative is for a service to send pieces of its own interface into the conversation. A user can recognize Shopify, Hugging Face, or Monday without reconstructing their identities from prose. The opening mockup makes this concrete: charts, a product card, and an audio player appear alongside chat text. But recognizable presentation is only the first requirement. A user should also be able to interact with an embedded Hugging Face interface and have that interaction do something. MCP Apps covers both UI delivery and communication with the host.

Chat mockup with blue text bars, a pie chart, a product card, and an audio player.Open full source frame
App interfaces embedded alongside text in a chat response.
0:180:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:18 · section reference included

From MCP-UI to a shared extension

Salomon dates MCP-UI’s creation to May of the previous year. Its scope was interactive applications over MCP: transmitting an interface and defining how it communicates with the application hosting it. Collaboration with Anthropic and OpenAI then produced the official MCP Apps extension. The launch account identifies MCP-UI and the OpenAI Apps SDK as predecessors; initial availability included Claude and Goose, VS Code Insiders support, and ChatGPT availability beginning that launch week. The important transition is from an individual implementation to a shared contract that multiple hosts can support.

Yosef names ElevenLabs, Shopify, and Postman among the early adopters. Goose provides a useful continuity example: he describes it as the first client to support MCP-UI and connects that work to a Block agentic commerce release announced on the day of the talk. He then widens the ecosystem to Cursor, Copilot, GitHub, and ChatGPT, where he says OpenAI recommends MCP Apps as the protocol for building applications.

Slide showing a document titled “MCP Apps compatibility in ChatGPT” over screenshots of social posts.Open full source frame
MCP Apps compatibility documentation for ChatGPT.

The ecosystem also includes community plugins, agent integrations, courses, and an integration with Pi. The official ext-apps repository provides a place to propose changes and submit pull requests. Yosef describes an open MCP working group that meets every three weeks, bringing Anthropic, OpenAI, and other partners together with community contributors. The intended audience for the protocol is broader than the large labs that implement its most visible hosts.

2:222:38
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:22 · section reference included

Deliver HTML, then let the host coordinate actions

The first mechanism uses an existing MCP primitive: a resource. In the text-only flow, Claude calls an MCP server and receives text to incorporate into its answer. With MCP Apps, the server can provide an HTML resource, and a supporting host can render it as an interactive application. Salomon illustrates the difference with a soundtrack interface: the response becomes something the user can browse and operate, rather than a description of the soundtrack.

Favoriting a song introduces the second mechanism. In the demonstrated Spotify flow, clicking the favorite button sends a message to the host and recommends calling a tool on Spotify’s MCP server. The host decides whether to invoke that tool. A click is therefore a request entering a coordinated flow; it is not itself evidence that the favorite has been saved.

Host mediation does not require a model turn for every interaction. The draft specification permits app-to-server tool calls through the host and declared external network access. The Spotify example explains who coordinates the requested action, rather than establishing that every backend request must become a chat message.

4:585:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:58 · section reference included

From funnel status to a clickable explanation

The PostHog demonstration starts with a product manager asking Claude for the status of a funnel. Claude reaches out to the PostHog server and returns a textual answer. Salomon describes it as factually correct but difficult to scan: the user still has to read through the response to understand where the funnel stands.

The follow-up is simply “Show me.” Because both the PostHog server and the Claude host support MCP Apps, the answer can become a branded, interactive PostHog widget. This preserves the service’s visual language inside the assistant and makes the funnel easier to inspect at a glance. The assistant supplies the conversational context; PostHog supplies the interface suited to its data.

The next question changes the job from inspecting analytics to learning what a funnel means. In Salomon’s demonstration, Claude produces a generated interface, streaming HTML into the answer. That interface is also interactive. Clicking a particular funnel step sends a prompt back to the model asking it to explain that step, so the user can continue the conversation through the visual representation itself. The interface is both an answer and a way to ask the next question.

6:356:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:35 · section reference included

The resource and callback loop

The architecture behind the funnel demonstration follows a small sequence:

  1. Prompt: the user asks for funnel information.
  2. Tool call: the assistant calls a tool whose definition links it to a UI resource.
  3. Resource registration: the server registers the HTML that implements the view.
  4. Resource consumption: the host obtains that HTML and prepares to display it.

Salomon notes that hosts commonly preload the resource rather than waiting until the moment of display. Prefetching is an optimization the protocol permits, not a requirement of the sequence.

On the rendering side, he describes the MCP-UI SDK as providing a React component or web component that accepts the resource and a communication callback. The interface runs in a sandbox. The callback gives interactions inside that boundary a route back to the host. This separation lets the service own its interface while the host owns the surrounding conversation and action coordination.

A click travels through that callback, and the host can use the resulting event to continue the agentic flow with a tool call or resource request. For the funnel explanation, the application-level TypeScript handler can be kept as small as this:

typescript

type FunnelStep = {
  id: string;
  label: string;
};

type RequestExplanation = (prompt: string) => Promise<void>;

export async function explainFunnelStep(
  step: FunnelStep,
  requestExplanation: RequestExplanation,
): Promise<void> {
  await requestExplanation(
    `Explain the ${step.label} step in this funnel (step ID: ${step.id}).`,
  );
}

Here, requestExplanation is the callback supplied by the application’s host integration. The handler turns the selected step into a specific request; the host determines how that request advances the conversation. The SDK handles the communication boundary rather than making the embedded view responsible for the whole agent loop.

8:468:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:46 · section reference included

Compose the task from pieces of services

The same architecture suggests a different way to consume the web. Instead of opening each service and translating a task into its dashboard controls, a user could give the task to a personal assistant. Yosef’s example is planning an anniversary: coordinating Google Calendar, shopping on Amazon, and finding accommodation through Booking, repeatedly carrying the same intent between them.

Yosef illustrates the friction with 20 browser tabs and a rhetorical estimate that 99% of the displayed UI is unnecessary for his task. Each service presents its broad interface because it lacks the assistant’s context. His proposed alternative is to break those interfaces into smaller pieces that Claude, ChatGPT, or OpenClaw can compose using MCP-UI. The slide separates shopping cards, calendar columns, booking controls, and a map into individual fragments.

Slide arranging flower shopping cards, calendar columns, booking controls, and a map as separate interface fragments.Open full source frame
Shopping, calendar, and travel interfaces separated into smaller pieces.

In the proposed workflow, a proactive assistant notices the approaching anniversary and displays a Google Calendar fragment. Yosef identifies three complementary benefits:

  • User familiarity: the user recognizes an interface they already know and trust.
  • Provider identity: Google retains its recognizable product experience.
  • Host reuse: the assistant does not need to rebuild the calendar’s capabilities itself.

The fragment is useful because it carries both functionality and recognizable context into the conversation.

Shopping can work the same way: Amazon remains a recognizable shopping experience instead of becoming a list of items in prose. A Booking.com map can appear when location becomes relevant. Yosef’s agentic-web vision is that the assistant, which holds the user’s broader context, assembles the pieces needed to complete the task without sending the user through each full website.

10:1410:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:14 · section reference included

The host owns the wider journey

Once interfaces can appear inside a shared assistant, an individual application no longer determines the whole user journey. A click in Shopify’s MCP app becomes part of a flow coordinated by the host. Amazon may participate in the shopping step without seeing the complete cross-service task. Yosef connects this mediation to auditability: the chat can provide a place to understand how the broader interaction proceeds.

Two interaction modes are explicit in this part of the explanation:

ModeWhat the app suppliesWhat the host receives
NotificationInformation that something happenedContext about an interaction
Prompt requestA request to continue the conversationResponsibility for the next conversational step

The difference is how much initiative the application hands back to the host. Yosef presents this change in interaction design as part of his forecast that MCP Apps will become a global UI standard in 2026.

The specification is still evolving. Salomon distinguishes community work already included from contributions and proposals still under discussion, and points developers back to ext-apps, which hosts the official SDK and specification under the Model Context Protocol organization. He says the maintainers reflect specification changes directly in the SDK, making its examples and open issues the practical entry points for both adoption and contribution.

12:2512:37
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:25 · section reference included

Keep expensive views alive and let the host operate them

Reusable views address a cost that becomes obvious with heavier applications. Salomon uses Autodesk’s full 3D renderer as the example: repeatedly rebuilding the application is slow and inefficient. He describes repeated rendering as an MVP limitation and proposes a possible server-provided identifier that would let the model keep updating the same view. The proposal is about preserving an existing application instance across subsequent interactions, rather than creating another expensive view each time.

The next capability reverses the direction of communication. So far, a user acts inside the app and the app talks to the host. What happens when the user asks the assistant to fill out a form? The host needs a way to operate the app. Yosef compares this to WebMCP, Chrome’s proposed APIs for exposing structured website interactions to agents, introduced in early preview. He calls the MCP Apps capability both App Tools and View Tools.

At the time of the talk, Yosef describes those tools as in the specification and awaiting release. The inspected draft expresses the mechanism through an app tools capability and bidirectional tools/list and tools/call; that draft status does not establish a shipped release. The architectural distinction is clear: the host can discover operations exposed by a view and request an operation such as filling its form, instead of relying solely on events initiated inside the interface.

14:1614:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:16 · section reference included

One protocol across different ways of building UI

MCP Apps also sits across a spectrum of interface construction. At one end, a provider supplies a predefined application, illustrated by Altara’s interface inside an iframe. In the middle, declarative systems such as json-render and A2UI supply instructions that a renderer turns into an interface. At the other end, the model generates the UI itself.

ApproachWhat determines the interface
Predefined UIApplication code supplied by the provider
Declarative UIA structured description interpreted by a renderer
Fully generated UIInterface code generated for the request

MCP Apps is agnostic about how the UI is generated. Its role is to carry an interactive application into a supporting host and provide communication around it. Yosef identifies Claude Apps’ Imagine feature as an example of generated UI using MCP Apps behind the scenes.

Interoperability therefore does not require choosing one construction approach for every host. Yosef describes serving A2UI to Gemini while wrapping it as an MCP app for ChatGPT, and also discusses interoperability in the other direction. The coauthored A2UI and MCP Apps guide explains concrete integration patterns, including packaging an A2UI renderer inside an MCP App. These are ways to bridge rendering environments; individual hosts still need the relevant support and configuration.

The portability demonstration brings that idea back to a single codebase: Yosef shows the same app in LibreChat, an open-source client, and ChatGPT. Both hosts support MCP Apps, so the application can retain its implementation while appearing in different assistant environments. The useful promise is reuse across supporting hosts, with the host integration providing the surrounding conversation.

15:2915:39
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:29 · section reference included

An application distribution channel

Salomon closes by treating MCP Apps as a new distribution channel for software. Salomon cites Sam Altman’s earlier figure of 800 million weekly ChatGPT users, describing it as roughly 10% of the world’s population. OpenAI’s historical enterprise AI report separately reported more than 800 million weekly users in December 2025. That is a platform audience, not the measured audience of an individual MCP app.

He says the web took around 13 years to reach that audience and claims a potential market 170 times the Apple App Store’s at launch. His intervening reference to growth beyond one billion does not identify a clear population, and the talk provides no calculation for those comparisons. The practical distribution argument rests on the named surfaces—Slack, VS Code, Claude, and OpenAI—where applications can meet users inside an existing assistant workflow.

For app developers, the starting point is the examples in ext-apps: clone an example and build on its resource and interaction structure. For host developers, Salomon points to ext-apps and the MCP-UI documentation. The repository’s example gallery makes the entry point concrete, and Yosef invites contributions to the official project.

Repository screenshot with example tiles beside the words “Official MCP Apps Repo” and a QR code.Open full source frame
The official MCP Apps repository and its example gallery.

The closing ambition is to write an application once and make it available across supporting assistants. Salomon qualifies the vision as “not quite Jarvis,” but the direction is specific: services retain useful interfaces, users interact with them inside the conversation, and the host coordinates the task that spans them.

17:0117:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:01 · section reference included

Resources

From the talk

  • The official launch account explains resource delivery, host communication, security, and initial client support.

Transcript download
Full transcript

Loading transcript…