Vibe Coding Builders
← Guides
Guides

How to Build Claude Interactive Apps That Still Work When Claude Withholds the New Features

Claude interactive apps are MCP Apps: a tool on your remote MCP server opens a sandboxed web view in the conversation. The inline view reaches every install; the side panel, app tools, entry points and embedded sites added on 2026-11-10 depend on each user's organization, interface and listing, so build them as upgrades.

On November 10, 2026, Anthropic said a developer's "full app can run inside Claude." That was the announcement for interactive connectors, and it added app tools and embedded sites in public preview.

The developer docs for those pieces are more careful. App tools "are available to a limited set of organizations, and not in every conversation." And an app installed from a Community listing gets no entry point, the tile that opens an app from Claude's Artifacts page without a prompt. A connector you submit to Claude's directory is listed as Community by default.

So the app you test and the app your users get can differ.

Claude interactive apps are MCP Apps. A tool on your MCP server points at an HTML page, and Claude renders that page as a live, sandboxed view inside the conversation.

The inline view reaches every user who connects your server. The side panel, app tools, entry points and embedded sites added on November 10 depend on each user's organization, interface and install. So build them as upgrades.

This guide builds the part everyone gets, then adds the rest in a way that fails quietly where Claude says no.

What is a Claude interactive app?

Anthropic first shipped interactive connectors on January 26, 2026. Asana boards, Slack drafts and Figma diagrams appeared as working views in the chat. The same day, the MCP maintainers made MCP Apps the first official MCP extension.

Users see an interactive connector. You build an MCP App.

The mechanism has two parts. A tool carries a _meta.ui.resourceUri field. That field points at a resource with a ui:// address, whose content is your HTML.

When Claude calls the tool, it fetches that resource and renders it in a sandboxed iframe, and the page then talks to Claude through JSON-RPC messages over postMessage.

Through that channel your view can receive the tool's result, call your server's other tools, and update what the model knows.

How a Claude interactive app opensA tool call in Claude flows from the tool's ui:// address to a sandboxed view, which talks back to Claude and your server over postMessageThe tool's _meta.ui.resourceUri is the only link between a plain MCP tool and its interface.

Your view gains no new access.

The help center says interactive connectors use the same permissions you granted when connecting the tool. Those connectors don't support purchases.

The standard grew out of MCP-UI and the OpenAI Apps SDK, and one codebase can run in Claude, ChatGPT, VS Code and Goose.

Build to Launch's explainer on MCP apps, connectors and plugins covers how the three fit together.

Start by asking whether text is enough

An MCP App is extra code. And Claude can already draw.

Claude builds its own custom visuals in HTML when a chart or diagram explains better than text. They are in beta, on web and desktop only, and ephemeral by default.

The help center sets the order between the two. When a connected service offers an interactive interface that handles the request, Claude uses it. Custom visuals "fill the gaps."

So an app earns its place when the interface belongs to your product. Think of a board with your data, a form with your validation, or a viewer for your files.

The MCP overview gives four reasons over a plain web link:

  1. The app stays in the conversation.
  2. It can call your server's tools.
  3. It can ask Claude to route actions to the user's other connectors.
  4. It runs in a sandbox.

Jack Ivers, one builder, built four MCP Apps in February 2026, for task triage, meeting prep, past interactions and Excalidraw previews. His first rule: "If you can live with text-only output, start there." So he built apps only where text fell short, and for two of the four he called the app an absolute must-have.

The pieces: a remote server, a tool, a resource and a view

The SDK is one npm package, @modelcontextprotocol/ext-apps. It has server helpers and a small browser client.

Claude's own quickstart adds a UI to a dice tool in about 50 lines, with no build step.

On the server, registerAppTool attaches the UI address to the tool. registerAppResource serves the HTML. Look at the _meta line and the ui:// URI, trimmed from the MCP Apps build guide:

const resourceUri = "ui://get-time/mcp-app.html";

registerAppTool(server, "get-time", {
  title: "Get Time",
  description: "Returns the current server time.",
  inputSchema: {},
  _meta: { ui: { resourceUri } },
}, async () => {
  const time = new Date().toISOString();
  return { content: [{ type: "text", text: time }] };
});

registerAppResource(server, resourceUri, resourceUri,
  { mimeType: RESOURCE_MIME_TYPE },
  async () => ({ contents: [{ uri: resourceUri, mimeType: RESOURCE_MIME_TYPE, text: html }] }),
);

The view is a web page that loads the App class. Set its handlers before it connects, or they never fire. Claude's troubleshooting page gives this order:

import { App } from "@modelcontextprotocol/ext-apps";

const app = new App({ name: "My App", version: "1.0.0" });

// Register handlers before connecting
app.ontoolresult = (result) => {
  // Handle tool results
};

await app.connect();

From there, app.callServerTool() lets a button in the view call your server again without a new prompt.

Host the server remotely from the start.

Claude's getting-started examples run locally through claude_desktop_config.json. They render inline. But in a view from a local server, Claude doesn't call app tools, the tools a view registers so Claude can change it. Entry points need a remote connector too. Ivers gives the same advice: default to remote OAuth servers and skip the local stdio shortcut.

Settings that decide whether the view renders

Four settings decide whether a view renders and what it costs.

Content security. All external origins are blocked by default. Each ui:// resource declares the origins it needs:

{ "_meta": { "ui": { "csp": {
  "connectDomains": ["https://api.example.com"],
  "resourceDomains": ["https://cdn.example.com"]
} } } }

connectDomains covers the API calls your view makes, while resourceDomains covers the scripts, styles and images it loads.

Builders reported both being ignored on claude.ai in February. In April, Anthropic staff said they should be working. A builder in the same thread confirmed that both now apply.

The sandbox origin. If your app runs its own sign-in, it needs a stable origin, set in _meta.ui.domain. For Claude, that value is the first 32 hex characters of the SHA-256 of your server URL, followed by .claudemcpcontent.com. Hash the exact URL users connect to. The troubleshooting page warns that https://example.com/mcp and https://example.com/mcp/ give different values. A mismatch shows an error instead of your app.

What the model reads. Keep the text result small and readable. When Claude's code execution is on, a result over about 150,000 characters is written to a file instead, and the app never loads its data.

Data meant only for the view belongs elsewhere. An issue filed in late October about Atlassian's MCP tools reported widget data reaching the model and raising token use. Anthropic staff replied that Claude Code and claude.ai are converging on what reaches the model, and that app-only data should go in the result's _meta field.

Display mode. An inline card should stay small. Claude's guidelines allow at most two actions and four or five data points, with no menus and no nested scrolling. Bigger work goes full screen.

In Claude, a view that goes full screen opens in a side panel beside the chat, where one is available. To open there without a click, set preferredDisplayMode: "fullscreen" on the resource. That field is Claude-only. Other hosts ignore it. Claude reports the mode as fullscreen for a view in the side panel too.

Which of the new pieces will your users get?

Each November 10 addition depends on conditions set per user. Your server can't see most of them. The docs spread them over several pages:

Table: What each piece of a Claude interactive app needs, as of 2026-11-12

PieceServerDirectory listingOther gates
Inline viewLocal or remoteAnyUser allows the app to display
Side panelNot statedNot statedLimited set of organizations; web and desktop, once the account has the unified Claude experience
App toolsRemote onlyNo conditionLimited organizations; unified Claude experience
Entry pointsRemote onlyVerified or custom; not CommunityLimited organizations; unified Claude experience
Embedded sitesRemoteLabel decides; Community reported blockedYour site must allow framing

Only the inline view has no listing or organization condition. The unified Claude experience is the new interface that merges chat and Cowork; an account whose message box still offers a choice of Chat or Cowork doesn't have it. Sources: Claude docs on display modes, app tools, entry points, connector verification, the November 10 announcement, and a report on the embedded-sites page.

The listing column matters most. You don't choose it.

Anthropic may escalate a Community listing to Verified, but its verification page says "there's no separate application for the Verified label."

You test with your server added by URL, which makes it a custom connector, but a user who installs your Community listing gets a different connector.

The entry-points page describes exactly this case. You keep the entry point. Your users have none.

Users see no message either. Claude shows no error when it leaves an app off the Artifacts page.

Embedded sites have a longer history. From February to July, builders asked for third-party iframes inside their apps. In April, Anthropic staff answered: "we can't allow nested iframes on claude.ai at the moment (security concerns)."

November's embedded sites let an app load its own website. The connector's label decides whether that works.

Build each upgrade so the base still works

If many installs won't get these pieces, they still pay off where they land. A Confluence page or a Box file open beside the chat, edited by Claude while you watch, is among the launch examples.

So add them without breaking the install that lacks them.

App tools. They are optional by design. An app tool lets Claude change the open view: the docs' example adds milk to a shopping list on screen. Register it in the view's script with app.registerTool (ext-apps 1.7.0 or later), before app.connect(). Trimmed from the app-tools page, look at the zod schema and the text the tool returns:

app.registerTool("add_item", {
  title: "Add item",
  description: "Add an item to the shopping list that is open in this view.",
  inputSchema: z.object({ name: z.string().describe("The item to add") })
}, async ({ name }) => {
  // add the item to the list on screen
  return { content: [{ type: "text", text: "Added " + name + "." }] };
});
await app.connect();

The app-tools page says to "keep your app working without app tools", and that "in an organization without app tools, the rest of the view continues to work."

Four limits from the app-tools page shape the design:

  1. A call has 45 seconds to run, and approval time is excluded. Start longer work and return, then report the outcome with a second tool.
  2. A view can hold 64 tools. One invalid schema hides all of them.
  3. Claude reads the first 100,000 characters of a result's text.
  4. A reloaded view starts from your HTML, so keep state on your server.

Approval also follows the definition. "Always allow" is saved for the tool as you defined it.

If you rename it or change its schema, Claude can ask for approval again.

Entry points. An entry point needs an empty start. You mark a tool with an openai/ui key, taken from OpenAI's extensions:

"_meta": {
  "ui": { "resourceUri": "ui://example/home" },
  "openai/ui": { "entrypoints": [{ "type": "global" }] }
}

A user who opens the app from the Artifacts page sends no request, so the arguments arrive as {}.

Make every input optional. Show a useful first screen. After a change, refresh the tools list under Customize, Connectors, or the entry point can take about two hours to appear.

Side panel. The side panel reaches a limited set of organizations. Where it can't open, a view that asked for it stays in the conversation. So the inline layout has to work on its own.

Embedded sites. These need a fallback link. Declare your site's origin in frameDomains on the view's resource. Then let Claude frame it through your site's frame-ancestors header, as the embedded-sites page outlines. According to Max Nardit's reading of the embedded-sites page, the view can read which frame origins Claude allowed after it connects, from app.getHostCapabilities()?.sandbox?.csp?.frameDomains. When yours isn't on the list, show a button that opens the site in a new tab.

That branch is where a Community install lands.

Assemble and test in the order your users meet it

Each step below adds one piece and checks it before the next:

  1. See one work. Connect an example server in Claude Desktop, ask Claude to use it, and click Allow.
  2. Add a view to your server. Follow the quickstart, or install the MCP Apps skills in Claude Code and ask for one.
  3. Deploy it remotely. The quickstart notes that seeing the UI render needs the server hosted where Claude can reach it.
  4. Compute ui.domain from the exact URL, if your app signs users in.
  5. Add it as a custom connector and test the inline view in a new chat on the web. Share the prefilled install link with testers.
  6. Add one app tool. Set the permission setting in the message box to Manual, so Claude asks before each tool call (in Auto it can skip asking). Open the app in one message, then ask for the change in a second.
  7. Submit to the directory, then install the Community listing from a second account. Expect no entry point there, and check the base still works.

Everything added on November 10 is a public preview whose implementation details may change. Check the gates table against the docs before each release.

For more on connectors, skills and plugins, see Build to Launch's Claude hub.

FAQ

Do Claude interactive apps work on mobile?

Inline views do. Claude's guidelines say the iOS and Android apps render MCP Apps in a native WebView, with no camera, microphone or location access. Users must add the connector on web or desktop before it appears on mobile.

Can my MCP App run in ChatGPT and VS Code too?

Yes, the same server can. MCP Apps launched with support in Claude, Goose, VS Code Insiders and ChatGPT. Claude-specific fields such as preferredDisplayMode and the .claudemcpcontent.com domain won't carry over, and hosts have handled security settings differently in practice, as issue #40 shows.

Can a Team or Enterprise admin turn interactive apps off?

Yes. Owners can disable the specific tool calls that render interactive connectors in Organization settings. The connector's text tools keep working.

Why does my app show the tool call but no interface?

The usual causes are a missing app.connect() call or a view with zero height, per Claude's troubleshooting page. On iOS only, check whether your server or CDN requires a Referer header, which WebKit omits; allowlist on the Origin header instead.

Sources

Links

Get new guides

New guides on building with AI come in the Build to Launch newsletter.

More guides