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

Ido Salomon, MCP Apps · Liad Yosef, MCP Apps

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/-jY2T2PiJBE-mcp-apps-extending-frontier) · [Video](https://www.youtube.com/watch?v=-jY2T2PiJBE)

## 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.

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?

[0:18](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=18s)

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](https://mcpui.dev/), 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.](https://ai.engineer/api/talk-essay-media/22e38a59834c49b3c0fe8254b89925b18d9304cc5b50b3c6599e00921a49a735)

App interfaces embedded alongside text in a chat response.

### From MCP-UI to a shared extension

[2:22](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=142s)

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](https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/) 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.](https://ai.engineer/api/talk-essay-media/bd93a60485f8c4413ef50e6029e911b884534a5a2e19852b515d4672df5e7ac9)

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](https://github.com/modelcontextprotocol/ext-apps) 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.

### Deliver HTML, then let the host coordinate actions

[4:58](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=298s)

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](https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/draft/apps.mdx) 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.

### From funnel status to a clickable explanation

[6:35](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=395s)

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.

### The resource and callback loop

[8:46](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=526s)

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.

### Compose the task from pieces of services

[10:14](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=614s)

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.](https://ai.engineer/api/talk-essay-media/b051ffd3012d651e9ef1069c995ff08ba1f75d45a53ee0aab5aa3b6e76c63803)

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.

### The host owns the wider journey

[12:25](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=745s)

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:

| Mode | What the app supplies | What the host receives |
| --- | --- | --- |
| Notification | Information that something happened | Context about an interaction |
| Prompt request | A request to continue the conversation | Responsibility 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.

### Keep expensive views alive and let the host operate them

[14:16](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=856s)

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](https://developer.chrome.com/blog/webmcp-epp), 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.

### One protocol across different ways of building UI

[15:29](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=929s)

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](https://github.com/vercel-labs/json-render/blob/main/README.md) and [A2UI](https://developers.googleblog.com/en/a2ui-and-mcp-apps/) supply instructions that a renderer turns into an interface. At the other end, the model generates the UI itself.

| Approach | What determines the interface |
| --- | --- |
| Predefined UI | Application code supplied by the provider |
| Declarative UI | A structured description interpreted by a renderer |
| Fully generated UI | Interface 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.

### An application distribution channel

[17:01](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1021s)

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](https://openai.com/index/the-state-of-enterprise-ai-2025-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.](https://ai.engineer/api/talk-essay-media/47b8f73bef5bc4efce9a7ed03ee06737f45cfeafb65d6e4a9a94b7836961d2df)

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.

## Resources

- [MCP Apps specification and SDK](https://github.com/modelcontextprotocol/ext-apps) — Official repository for the MCP Apps specification, SDK, examples, and community contributions.
- [MCP-UI](https://mcpui.dev/) — SDK documentation and examples for rendering interactive MCP interfaces and registering UI resources.
- [MCP Apps launch announcement](https://blog.modelcontextprotocol.io/posts/2026-01-26-mcp-apps/) — The official launch account explains resource delivery, host communication, security, and initial client support.
- [Combining A2UI and MCP Apps](https://developers.googleblog.com/en/a2ui-and-mcp-apps/) — The speakers and Google's A2UI team explain three integration patterns, with implementation guides and sample applications.
- [WebMCP early preview](https://developer.chrome.com/blog/webmcp-epp) — Chrome's introduction to structured website tools through declarative forms and imperative JavaScript APIs.
- [json-render](https://github.com/vercel-labs/json-render/blob/main/README.md) — Vercel Labs' framework for generating interfaces from structured specifications.

## Slides

### Ido Salomon

Ido Salomon introduces himself as the creator of MCP-UI and AgentCraft, and a co-creator and maintainer of MCP Apps.

[0:17](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=17s) [Ido Salomon’s portrait and professional roles.](https://assets.ai.engineer/sites/aiecode2025/sha256/4ad2c3eb9850746f2b292f0619597d4fb455832194118ec50388b0791043f085.webp)

Ido Salomon
Creator @ MCP-UI
Co-Creator & Maintainer @ MCP Apps
Creator @ AgentCraft

X: @idosal[illegible]
GitHub: idosal
LinkedIn: ido-salomon

### Liad Yosef

Liad Yosef works with Ido on MCP-UI, co-created and maintains the MCP Apps spec, and co-founded Ora.

[0:28](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=28s) [Liad Yosef’s portrait and professional roles.](https://assets.ai.engineer/sites/aiecode2025/sha256/b5aa2a01ada0aa0265381d57a4cad03be7251f1f71e22e1e927eb7896f49fba1.webp)

Liad Yosef

Collaborator @ MCP-UI
Co-creator & Maintainer @ MCP Apps
Co-founder @ Ora

X: @liadyosef
GitHub: liady
LinkedIn: liadyosef

### Onboarding analysis in chat

The chat reports that a new onboarding flow deployed Monday improved activations by 40%. The user asks where the old flow was losing people.

[0:56](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=56s) [A chat reports improved onboarding activation and asks where the old flow lost people.](https://assets.ai.engineer/sites/aiecode2025/sha256/b62dd4fe52737db155e678ebedcff85bb08684c70f52d42b62aafa2fa4ebbed8.webp)

Found it. A new onboarding flow was deployed on Monday that has already improved activations by 40%. Early results look strong!

Makes sense! Can you show me where the old flow was losing people?

Interface text:
Daily, Last 10 days | Amplitude 2.0
+

### We’re used to text, but

The speaker argues that walls of text make information hard to convey, and that companies do not want their data reduced to a textual database or their brand identity lost.

[0:59](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=59s) [A slide reads, “We’re used to text, but –”.](https://assets.ai.engineer/sites/aiecode2025/sha256/0089630c81b29c93be849e0f64162e2493e7f4612b7c586567c12082a420ac3d.webp)

We’re used to text, but –

### Apps sending their UI to chat

The speakers propose letting apps send their own interfaces into chat, preserving their brand identity and user experience instead of reducing their data to text.

[1:41](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=101s) [A slide asks what if every app could send its own interface to the chat.](https://assets.ai.engineer/sites/aiecode2025/sha256/e1520bb039ac946ad83d6ce8c0276b9cf8e209b94fde44b70fa0cbc51949b95f.webp)

What if every app in the world
could send its own UI to the chat?

### A text-only chat response

A chat response appears as rows of generic blue bars, illustrating how an app’s own visual identity can disappear in a text response.

[1:51](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=111s) [A chat response represented by rows of blue bars.](https://assets.ai.engineer/sites/aiecode2025/sha256/ec7adc048dd0532663b42a11cdc321af165d104cddbd5ca81aa8d612b8762e0e.webp)

Please show me my entries

Of course! Here is the entry for today:

Interface text:
LY
Reply to Claude...
Research
Sonnet 4.5

### App interfaces in chat

The proposed chat response embeds a dashboard, a product card and a Hugging Face audio player. The speaker wants users to interact with these app interfaces inside the chat.

[1:57](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=117s) [A chat response containing a dashboard, product card, and audio player among blue bars.](https://assets.ai.engineer/sites/aiecode2025/sha256/df1e2ce4e854a2d7efb559a779c8ff33e6d939050b21a365fccdfedb85d1111c.webp)

Please show me my entries

Of course! Here is the entry for today:

[Dashboard chart and table text illegible]

Women's Tree Lounger - Mist
(White Sole)
$100.00
[Product details illegible]
Add to cart
Buy now

evalstate/Chatterbox
Hugging Face
0:09 / 0:12

Interface text:
Reply to Claude...
Research
Sonnet 4.5

### Using MCP-UI

Salomon introduces MCP-UI as an open protocol for interactive applications over MCP, covering both UI transmission and communication with the host.

[2:20](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=140s) [The words Using MCP-UI on a dark background.](https://assets.ai.engineer/sites/aiecode2025/sha256/b6eb2990178c82aeee3f908848d5c0dc41efba65b5b0ead051d0d351daddc9ce.webp)

Using MCP-UI

### MCP-UI introduction

MCP-UI connects interactive UI components to MCP. Salomon’s post illustrates the idea with a performance dashboard and a Nudge button.

[2:27](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=147s) [An agentic interfaces event graphic beside a social post introducing MCP-UI and an interface preview.](https://assets.ai.engineer/sites/aiecode2025/sha256/a78f41ed7288463a233c18f7ca2b1e18a51612112518a87db777143eb482c299.webp)

Wild Goose Case
THE FUTURE OF AGENTIC INTERFACES

DATE: AUG 14, 2025
TIME: 12PM ET / 9AM PT
LOCATION: linktr.ee/blockopensource

ANDREW [illegible]
Design Technologist
Block, Inc.

LIAD YOSEF
AI,
monday.com

IDO SALOMON
AI,
monday.com

Ido Salomon · @idosal1 · May 16
Introducing MCP UI, the SDK that wires UI components directly into the MCP protocol 🤯

Watch the video to see the new phase in AI interaction!

Why browse when you can have universal apps that deliver the right UI to consume any data and perform any action?

Replace cumbersome walls of text with slick interactive components, bringing rich web experiences to MCP-enabled agents such as Claude and Cursor.

Let’s build Jarvis so @kentcdodds doesn’t have to! 🧵 >>

Dashboard preview:
Bob
Performance Overview
Average 125
Reach 91%
Timeline: Feb, Mar, Apr, May, Jun
1243 Completed
289 Pending
67 Blocked
Nudge

Interface text:
Promote
0:04
[illegible] a message...
Send

### An open protocol for interactive apps

MCP-UI standardizes both UI transmission over MCP and communication between the UI and its host.

[2:31](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=151s) [Text describes a protocol for interactive apps over MCP, standardizing UI transmission and communication between the UI and host.](https://assets.ai.engineer/sites/aiecode2025/sha256/4856c8fc667080039adf40293c2d6a7396823cb692e59c82ef97a101ead42137.webp)

An open protocol for interactive apps over MCP standardizing UI transmission and UI<>Host communication

### MCP-UI and AI partners

The MCP-UI team partnered with Anthropic and OpenAI to create MCP Apps, an official MCP extension based on MCP-UI, the MCP SDK, and other solutions.

[2:45](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=165s) [Three white marks on black: a stylized interface icon, the Anthropic logo, and the OpenAI logo.](https://assets.ai.engineer/sites/aiecode2025/sha256/2f18fb6c25fa7bdccd7fc37063ba1aba60be7515422753a83b7d42d04482afc5.webp)

### MCP Apps announcement

MCP Apps launched as an official MCP extension, allowing tools to return interactive UI components inside conversations. The speaker says Claude and VS Code supported it at launch.

[2:59](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=179s) [Announcement page introducing MCP Apps as an official MCP extension, with an embedded video error.](https://assets.ai.engineer/sites/aiecode2025/sha256/fc34e154b2294497509773e50c38273bfbda23d5c7567178f50aa49aa67f3e56.webp)

MCP Apps - Bringing UI Capabilities To MCP Clients

MCP Apps is now live as the first official MCP extension — tools can return interactive UI components that render directly in the conversation.

January 26, 2026 · 9 min · MCP Core Maintainers

▶ Table of Contents

Today, we’re announcing that MCP Apps are now live as an official MCP extension. Tools can now return interactive UI components that render directly in the conversation: dashboards, forms, visualizations, multi-step workflows, and more. This is the first official MCP extension, and it’s ready for production.

Interface text:
Home » Posts
Watch video on YouTube
Error 153
Video player configuration error

### Early MCP-UI adopters

Early MCP-UI adopters included ElevenLabs, Shopify and Postman. The speakers say Postman was among the first companies to support it, and Goose was the first client.

[3:11](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=191s) [Logos including TheFork, monday.com, ElevenLabs, Postman, Shopify and Obot on a dark background.](https://assets.ai.engineer/sites/aiecode2025/sha256/940e4e22e999677e362c6aaf760455630e0fd3e92a2670fec45c986b1a6d16d7.webp)

TheFork
monday.com
ElevenLabs
POSTMAN
shopify
obot

### SaaS scenario dashboard

A chat tool displays a 12-month SaaS scenario with rising MRR, gross profit and net profit, alongside $63.4K end MRR and break-even in month 1.

[3:45](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=225s) [Chat interface showing a 12-month projection chart and revenue and profit metrics.](https://assets.ai.engineer/sites/aiecode2025/sha256/2465810b1bd2a2f20d27bab5f96ae5b4b9564b8a714a86419c56a9dd52d5d862.webp)

12-MONTH PROJECTION
Y-axis ticks: $70K, $60K, $50K, $40K, $30K, $20K, $10K
Timeline: M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12
Legend: MRR, Gross Profit, Net Profit

YOUR SCENARIO
$63.4K End MRR
$684K Total Revenue
$187K Total Profit
Break-even: Month 1
MRR Growth: +26.8%

The get-scenario-data tool has returned several predefined SaaS growth scenarios. Here are the available templates:
1. Bootstrapped Growth (🌱)
   Description: Low burn, steady growth, path to profitability

Interface text:
CHAT
USING THE GET-SCENARIO-DATA TOOL
Add Context...
Describe what to build next
Agent
GPT-4o

### MCP Apps compatibility in ChatGPT

ChatGPT supports MCP Apps UIs through an iframe and a standard bridge, allowing the same UI to run in ChatGPT and other compatible hosts. Existing Apps SDK APIs remain supported.

[3:54](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=234s) [Documentation explains that ChatGPT supports MCP Apps and describes the iframe and communication bridge.](https://assets.ai.engineer/sites/aiecode2025/sha256/007e696639718a0ccc8b026cec4b29cd10a84f032ecc6c03805bcb2268050284.webp)

MCP Apps compatibility in ChatGPT
Build portable MCP Apps UIs that run in ChatGPT

Overview

ChatGPT supports the MCP Apps open standard for embedded app UIs.

MCP Apps UIs run inside an iframe and communicate with the host over a standard bridge (ui/* JSON-RPC over postMessage). ChatGPT implements this same iframe-and-bridge model, so you can build your UI once and run it in ChatGPT and other MCP Apps-compatible hosts.

Existing Apps SDK APIs remain supported, and new, experimental capabilities ship first in the Apps SDK. OpenAI helped shape the MCP Apps standard from ChatGPT Apps, and new capabilities move into the MCP spec after shape and functionality validation.

Build with the MCP Apps standard keys and bridge by default. Use window.openai when you need ChatGPT-specific capabilities.

Background text:
Apps Support in Postman
[illegible]

Interface text:
Sam Morrow · 2nd
Connect
Two ne[illegible]
- we sh[illegible]
- we sh[illegible]
Try it o[illegible]
Should [illegible]
Aaron Koivunen and 59 others
13 comments · 6 reposts

### Community MCP Apps integrations

Community integrations include Archestra’s merged support and a Pi demo that renders an interactive before-and-after code chart.

[4:16](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=256s) [A social post announces MCP Apps support in Archestra beside a Storybook preview in a chat interface.](https://assets.ai.engineer/sites/aiecode2025/sha256/f2523c12570d73d1b6872dcf60d7baacfc70a5841da7c2f2184e377a3b4f310d.webp)

Matvey Kukuy · 2nd
CEO at Archestra, ex. Engineering Director at Grafana. OSS ...
6d · 🌐

MCP Apps support has been merged into Archestra v1.1.40!

Thank You
KubeCon Amsterdam
2026

Example/Header - Logged In
Acme
Welcome, Jane Doe!
Sign out

Example/Header - Logged Out
Acme
Sign in
Sign up

Example/Page - Logged In
Acme
Sign in
Sign up

Pages in Storybook

We recommend building UIs with a component-driven process starting with atomic components and ending with pages.

Render pages with mock data. This makes it easy to build and review page states without needing to navigate to them in your app. Here are some handy patterns for managing page data in Storybook:

• Use a higher-level connected component. Storybook helps you compose such data from the “args” of child component stories.
• Assemble data in the page component from your services. You can mock these services out using Storybook.

Get a guided tutorial on component-driven development at Storybook.

Interface text:
Follow
25
1 comment · 1 repost
CHAT
UPDATING BUTTON LABELS IN PAGE COMPONENT
Ran Preview stories - Storybook MCP (MCP Server)
1 file changed +2 -2
Keep
Undo

[4:22](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=262s) [An interactive before-and-after bar chart displayed over a terminal and community screenshots.](https://assets.ai.engineer/sites/aiecode2025/sha256/105f483eb78bf31d3ff3fd2e53a24268f211abe27a9d5485f3bcd49726662df1.webp)

Nathan Tarbert · 1st
DevRel - CopilotKit
2w · Edited · 🌐
MCP Apps + CopilotKit is actually next-level Generative UI!

Lines of Code — Before vs After
Legend: Before, After
Y-axis ticks: 0, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1,000
Categories: ui-session, server, [illegible], css, schema

Interface text:
great just restarted pi lets test the mcp demo again
mcp
Rendered bar chart: Lines of Code – Before vs After
Interactive UI is now open in your browser. [illegible]
Chart's up. Try interacting with it – send a message
Shaolin servers loading...
MCP - interactive-visualizer
show_chart
Sandboxed
Connected
Done
Cancel
change [illegible]
Send

### MCP Apps Workgroup

The open MCP Apps workgroup meets every three weeks to discuss the protocol’s future and make the spec serve the community as well as large labs.

[4:26](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=266s) [MCP Apps Workgroup slide showing a meeting agenda document.](https://assets.ai.engineer/sites/aiecode2025/sha256/b3045504bdee45b1c9e80e11274e1e9584e29148abcd9649d9a03bbaa02bf2d3.webp)

MCP Apps Workgroup

MCP Apps Workgroup Agenda

This document serves as a rolling agenda for the MCP Apps Workgroup tri-weekly meetings. For offline discussion, please use the SEP-1865 PR, the ‘ext-apps’ repository or the ‘mcp-apps-wg’ channel in the MCP Contributor Discord. For deeper-dives, you can also use the dedicated community Discord server.

Meeting 5
Date: Mar 19, 2026 12:00 PM PDT
Moderators: Ido Salomon, Liad Yosef
Attendees:

Agenda

Topic | Reference | Assignee | Notes
Adoption! | | | Cursor, Pi, [illegible]
Model state | Issue (model context); Issue (notification) | Ido Salomon | [illegible]

Interface text:
Document tabs
Tab 1
MCP Apps Workgroup Ag...
Meeting 5
Meeting 4
Meeting 3: Post-launch!
Meeting 2: Finalize SEP o...
Meeting 1: Discuss open i...

## Full transcript

[0:00](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=0s) [upbeat music] Hi. Uh, so hi, everyone. Uh, we did this talk yesterday, so it might be out of date. [laughs]

[0:18](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=18s) I'm Ido Salomon. I am the creator of MCP-UI, and co-creator and maintainer of MCP Apps in the MCP steering committee. I also created AtomCraft, if you were in the talk yesterday.

[0:30](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=30s) I'm Liad. I work with Ido on MCP-UI. I'm also the co-creator and maintainer of the MCP Apps, uh, spec, and recently co-founded AURA, which is a research lab for the agentic web, and we're gonna talk a little bit more about it later.

[0:45](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=45s) So MCP apps are all around us. You might not even realize it, but all the fancy apps you have today in ChatGPT, in VS Code, in Slack are actually all based on MCP and the MCP apps spec.

[1:01](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=61s) And if we take a step back and we ask, "Why do we need MCP Apps? What's the idea behind MCP-UI or MCP Apps?" So when we work with chats, with chat clien- clients, we use the text because that's the natural interface, but text is really the worst way to convey a lot of information, right?

[1:18](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=78s) Because we don't want walls of text, and actually, this is the main blocker from companies to, uh, build an MCP server. They don't want to be reduced to a textual database.

[1:27](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=87s) They don't want to lose their brand identity in the process. They don't want their data that they worked so hard on, uh, um, building the UX for to look something like this.

[1:38](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=98s) So instead of this, what if the apps could just send their UI to the chat, right? What if every service and every brand could just send their user interface to the chat?

[1:51](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=111s) So instead of us looking at something like this, we could just have the apps send their own identity, their own UI chunks into the chat, and then we take a look, and we say, "Okay.

[2:02](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=122s) Yeah, I know this is Shopify in the middle. I know this is Hugging Face. I know this is Monday." And what if we don't want to do it only as a, a visualization?

[2:10](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=130s) We also want to do it interactive. So we want the users to be able to actually interact with Hugging Face, for example,

[2:18](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=138s) and for Hugging Face to actually do something with it.

[2:22](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=142s) So we don't have to imagine the future, as we said, uh, with MCP-UI, uh, which I created in May last year, uh, and took that, which is essentially like an open protocol for interactive applications over MCP.

[2:38](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=158s) So it's not only how you transmit UI, but also how that UI, that application, uh, connect, connect, communicates with the host. And just a few months ago, we partnered with Anthropic and OpenAI to create the official extension to MCP, uh, which we call MCP Apps based on MCP-UI, MCP SDK, uh, and other, uh, solutions in the field.

[3:01](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=181s) Uh, the launch was, uh, pretty cool with Claude and VS Code supporting it to begin with. But now, uh, uh, obviously, also OpenAI and others have adopted it.

[3:13](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=193s) Yeah, and, uh, there are a lot of early adopters to MCP-UI. Um, uh, ElevenLabs, Shopify, Postman, that was one of the, uh, first, first companies to support it back, like, a year ago.

[3:24](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=204s) They were the one believing in this spec, in this vision. Um, and, uh, uh, Goose, uh, also supported it, and it's a, it's a funny anecdote because today Block released their agentic commerce solution that is based on MCP Apps.

[3:36](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=216s) So a year ago, Goose was the first client to support MCP-UI, and now it is part of Block's, uh, um, uh, product, uh, product. Um, and today we have a lot more clients supporting MCP-UI.

[3:49](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=229s) Uh, we have, uh, uh, Cursor, and we have, um, yeah, Copilot, and, uh, uh, GitHub. ChatGPT support MCP Apps. ChatGPT apps that you know are actually based on MCP Apps, and OpenAI actually recommend using, um, MCP Apps as a protocol to build ChatGPT apps.

[4:07](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=247s) Um, Postman, um, and a lot more, and obviously, Claude supports MCP Apps. But you also have a lot, uh, uh, large community around it, right? So people start to, to build plugins to MCP Apps, uh, and, uh, um, uh, integrations to different agents and also courses on how to build MCP Apps.

[4:24](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=264s) This is Pi integration for MCP Apps. Um, so, uh, we have a large community around it. Um, there's a repo, ext-apps, which is the repo for MCP Apps, uh, where everyone can just come and propose PRs and ideas of how to, how to extend this, uh, spec.

[4:39](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=279s) And we have a work group in the MCP committee, and we're convening every three weeks. We have a tri-weekly meeting on the future of the protocol and how to make the spec not just, uh, serve the big labs, but also the community.

[4:51](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=291s) So it's an open working group with Anthropic, OpenAI, and all the, uh, partners in, in the MCP Apps protocol.

[4:58](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=298s) Okay, so let's look at a few of the core concepts of MCP Apps. Uh, the first and most obvious one is, how do we even transmit UI over MCP?

[5:08](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=308s) So if we look at this example of Claude, like, uh, you know, ancient times, like a few months ago, uh, and I would ask something, uh, best case scenario, it would reach out to my MCP server, and it would get back a textual response, which is obviously suboptimal.

[5:26](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=326s) So let's say I do want to get, uh, some- something better. Uh, so now ins- I can use existing MCP primitives, uh, like a resource, and now return HTML.

[5:38](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=338s) And I can take that HTML, and since Claude supports MCP Apps, it can turn it into an interactive application of the best soundtrack in the world.

[5:50](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=350s) And what if you want it to be really interactive, right? This is nice because it shows the best soundtrack in the world. What if I want to favorite one of the songs there?

[5:58](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=358s) I want interaction. I want communication between the app- And the host. So when a user clicks on the favorite button, MCP Apps actually standardizes this flow. So instead of the app sending a message to, to the backend, to Spotify's backend, it's actually sending a message to the host saying, "Hey, user clicked a button.

[6:19](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=379s) Do something with it. I recommend you to call a tool in Spotify's MCP server." And the host decides what to do. The host keeps this control of the flow.

[6:27](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=387s) In this case, the host can decide to actually call the favor- favorite tool, and MCP Apps standardizes this flow.

[6:35](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=395s) Okay. So seeing is believing, so let's see an example from Claude.

[6:42](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=402s) Yeah. Uh, so let's say that I'm a product manager and I want to understand the status of my funnel. So I would go to Claude and I would ask, "What's the status?"

[6:51](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=411s) In the, again, old world of a few months ago, uh, I would get back this textual response. Let's say that it's PostHog. So it reached out to the PostHog server, got back a textual response.

[7:01](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=421s) It's factually correct, but it's useless. I mean, how do I even take that and understand quickly what's going on? I have to read, which I don't wanna do, uh, and it's pretty challenging.

[7:12](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=432s) Uh, but luckily, because both Po- PostHog server and Claude as a host support MCP Apps, I can just say, "Show me." And now instead of getting that block of text, I can actually get something useful, uh, which is this interactive, um, widget that you would get, you know, on the PostHog, uh, uh, server.

[7:33](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=453s) And when you have that, you can at a glance see what's going on, and as you can see, it's branded PostHog. So you're actually getting the PostHog experience within ChatGPT or Claude, et cetera.

[7:45](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=465s) Uh, but it doesn't really end there. Uh, as we said, MCP Apps is also like an interactive protocol. So not only can I see and, and interact with it, I can also do stuff like, uh, ask them to explain what a funnel is.

[7:58](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=478s) I might not even know that. So again, instead of getting that huge wall of text explaining what a funnel is, I can just get this generative UI answer from Claude, which uses MCP Apps.

[8:09](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=489s) It streams, like, the HTML inside, and now I can get this nice interactive, uh, experience of learning. And not only is it, uh, visually nice and helps me understand, but it's also fully interactive.

[8:22](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=502s) And when we say interactive, it actually means that clicking it would help me communicate with the host. So let's say that I want to understand, like, a particular step in the funnel.

[8:33](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=513s) Uh, I just go and I click on it, and since it's an MCP App, it can send a prompt back to the, uh, model and say, "Okay, explain this specific step to me," and I can advance the flow.

[8:46](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=526s) Uh, so this is, uh, like the example of, of how that, uh, looks. So how does it actually work if you look at the architecture of it? Uh, so we started by prompting, so we typed something in.

[8:58](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=538s) Uh, we asked for, uh, the funnel information. A tool call went out. Since our server supports MCP Apps, that tool call is actually linked to a resource. And if you look at the code here, then, you know, it's, it's a re- so just a resource with, uh, uh, some prefix.

[9:15](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=555s) Uh, we take that. It's pretty simple code. We can just add, register the, the resource with the HTML and you're done. Uh, that resource is then, um, consumed by the host.

[9:27](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=567s) In practice, it's usually consumed beforehand, like it's preloaded, uh, but imagine that it's just consumed in real time. That same HTML then passed to the host that also supports MCP Apps.

[9:37](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=577s) MCP Apps is basically, if you look at the MCP-UI SDK, just a React component or a web component that just accepts that resource, plus, uh, a callback, which is how we implement that, uh, communication protocol you saw earlier, and renders it in a sandbox.

[9:54](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=594s) So like we said, not only is it presentational, I can click. So what happens when I click? So we click on it. It sends back through that callback, uh, the event all the way up.

[10:04](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=604s) The model takes that event, and then it can send out a tool call, uh, or, uh, uh, call a resource or anything else, thus completing the agentic flow.

[10:14](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=614s) And this architecture actually brings a new philosophy or a new vision to the web. So instead of, uh, us thinking of the web as tabs or, um, services that we need to consume using a browser, we're now consuming it using our own personal assistants, right?

[10:30](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=630s) What does it mean? It means that if I want to co- uh, accomplish a task, for example, plan a, um, anniversary. So up until now, I had to open 20 tabs in the browser, and I had to try to convey my intent to each of those services.

[10:43](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=643s) And by saying, "Conveying my intent," it means that I have to interact with the dashboards of the UIs of those companies. So just to plan anniversary, I need to convey my intent to Google Calendar and Amazon and Booking and Booking again and Amazon again, and all...

[10:59](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=659s) And I don't need 99% of the UI that is shown there because this UI doesn't know me. It doesn't have the context on me. What if we could just take these UIs and just break them into atoms, and those atoms can be composed by my own personal assistant, right?

[11:14](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=674s) Because I don't need the, the UI. I need those atoms. So if we can take these atoms and have my Claude or ChatGPT or OpenClaw just use them using MCP-UI, we can have this flow.

[11:28](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=688s) So my proactive assistant can say, uh, "Yeah, I know. I see that you have, uh, an anniversary coming," and instead of just showing me data from Google Calendar, it can display Google Calendar chunk.

[11:37](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=697s) Now, for me, it's good because I know Google Calendar. I trust Google. For Google, it's good because it maintains their brand and identity, and for the host, it's good because they don't need to develop this capability themselves.

[11:48](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=708s) And it goes even deeper because if I'm interacting with Amazon, instead of Amazon being reduced to just a list of items or, uh, or text- I can see Amazon.

[11:57](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=717s) I can, I can know that this is, uh, this is Amazon, and I can complete my entire flow without even leaving my assistant, and this is the agentic web.

[12:07](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=727s) This is how we are going to consume the web, because my assistant will have the context on me. It n- it will know to pull the, the map from Booking.com.

[12:15](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=735s) I don't need to know that, right? So this is going to be the shift that we're gonna see very soon, where websites are going to shift into small chunks of UIs inside, uh, inside personal assistants.

[12:25](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=745s) Um, and with that come new interaction mindset because, um, if I click on something in the Shopify's MCP app, then Shopify doesn't control my journey anymore, the host does.

[12:37](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=757s) Um, and no application will control the user journey anymore, so Amazon won't be able to know—to see my flow. It- everything will go through the chat for auditability.

[12:46](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=766s) Um, and MCP apps actually standardizes it by defining these three level of control over the user journey. So an app can notify the chat that something happened, or an app can actually ask the chat to run a prompt and s- and releasing all responsibility to the chat.

[13:02](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=782s) So MCP apps actually standardize it, and this is the new software flow, the new flow of interaction that we're gonna see between applications, the chats, and the users.

[13:13](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=793s) Um, in 2026, we had, we had an amazing year of standardizing MCP-UI, and 2026 is going to be the year where it's going to be a global standard for UI.

[13:23](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=803s) Yeah.

[13:23](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=803s) But it's still evolving. Uh, there's a lot of stuff going on. Uh, even in these past few months, these are some of the things that are already in or already contributed or proposed, uh, by the community.

[13:34](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=814s) Uh, so you still have a lot of time and a lot of room to influence how this future will look like. Uh, so you can go to ext-apps, uh, that's the official SDK, and spec is also hosted there.

[13:45](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=825s) It's under the official Model Context Protocol, uh, repository. There will be a QR code later, uh, so you don't have to, uh, to, uh, uh, photograph it. Uh, and also, um, the, the cool thing about using ext-apps in particular is that because it's maintained by us directly, uh, all changes to the spec are immediately, uh, reflected

[14:05](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=845s) in the SDK. So if you use that SDK, then you automatically get all the new stuff out of the bag. Uh, these are some of the issues that we have, so please feel free to come and, uh, contribute.

[14:16](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=856s) So what's next? Um, there's a bunch of stuff coming up. Uh, the first thing, uh, that we get a lot of, uh, uh, of asks for is kind of reusable views.

[14:27](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=867s) So if you have, uh, um, companies like Autodesk that have really heavy apps, like they have, you know, the entire 3D renderer there, they don't want to keep re-rendering that over and over again because it just, it takes time, it's inefficient.

[14:42](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=882s) Uh, that's just the way that we had to do it, uh, for, uh, the MVP. But we are working on thinking of maybe we can pass some identifier from the server, uh, in a way that would help the model actually keep updating the same view.

[14:56](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=896s) Uh, the other way to do this is...

[15:00](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=900s) Um, App Tools, which is something, uh, if you've heard of WebMCP, which is Google standard of how agents will interact in, with web views. So in MCP apps, we actually standardized it into App Tools.

[15:10](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=910s) So up until now, we saw the flow where users do- does something in the app and the app talks to the host. But what if the host or the chat wants to speak to the app?

[15:20](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=920s) If the user writes something, uh, "Fill out this form for me," and the chat will fill out the form for the user. So MCP apps actually standardizes this, this flow, which we call View Tools.

[15:29](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=929s) That's actually, that's in the spec right now. It's also, uh, it's gonna be released, uh, very soon. Um, and we're working on this generative UI spectrum, where you have predefined UIs, that's MCP apps.

[15:39](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=939s) That's like the black box, uh, iframe that renders, uh, um, Altara's UI in that example. But you also have other things on this spectrum like, like declarative UI, like JSON Render or A2UI.

[15:51](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=951s) These specs that say, uh, yeah, the, the app just returns an instructions on how to build the UI, but the chat will actually build the UI. And you have fully generative UI on the other end of the spectrum.

[16:01](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=961s) And if you know Claude Apps, uh, yeah, MCP apps is agnostic to the way the UI is generated. And if you know Claude Apps' Imagine feature, uh, where you can just ask Claude to generate a UI for you, that's actually based on MCP apps.

[16:14](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=974s) So this is an MCP app behind the scenes, but it supports generative UI. Um, so we're working on interoperability with those other, uh, um, standards. And actually just a few days ago, we, uh, re- released a guide on how to do A2UI, which is a generative UI standard, and MCP apps, which is this standard, how to do

[16:33](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=993s) interoper- interoperability. How can a server can write A2UI and ship it to Gemini, but also wrap it as an MCP app to ship to ChatGPT, and vice versa.

[16:43](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1003s) Um, an MCP app is support everywhere, so it can run everywhere. If you build it once, it runs in LibreChat, which is an open source, uh, uh, MCP app supported client, but also in ChatGPT.

[16:51](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1011s) That's the same app that you're seeing, the same code base that runs in, in both, which is, uh, pretty cool. Yeah. Uh, yeah.

[17:01](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1021s) So this isn't just a technology, uh, or a cool feature. This is an entirely new way to distribute applications. So, uh, if you look just a few months back, then Sam Altman said that ChatGPT in particular has eight hundred million weekly users, which is ten percent of the entire world population.

[17:20](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1040s) That's insane. So if you think about the web in general, it took around thirteen years to get to that number of users. So if you look at that and you think that in the last few months, uh, we actually had, uh, a growth of o- over one billion just for that, we have like one hundred and seventy

[17:36](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1056s) times the total addressable market of the Apple App Store when it launched. So MCP apps are everywhere. Uh, Slack just released it, VS Code, Claude, OpenAI, uh, et cetera.

[17:48](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1068s) It's already there. Uh, so how do you get started? Uh, you can clone those. You can, uh, uh, go to, like, ext-apps. Um, as a host, also, go to ext-apps or the MCP-UI website.

[17:59](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1079s) Um-

[17:59](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1079s) Please visit the official repo, [laughs] the ext-apps repo to get involved. Um, and yeah.

[18:05](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1085s) So embrace the new web. Uh, it's awesome. Uh, with MCP apps, you can write once and run it everywhere. Uh, and the future is looking bright, not quite Jarvis, but with MCP and MCP apps, we're close.

[18:17](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1097s) And come talk to us afterwards about it.

[18:18](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1098s) Thank you.

[18:19](https://www.youtube.com/watch?v=-jY2T2PiJBE&t=1099s) Yeah, thank you. [audience claps] [outro music]
