|
Technical Analysis • January 27, 2026
The Day Anthropic and OpenAI Agreed on Something
MCP Apps shipped yesterday. The technical spec matters less than who signed off on it: direct competitors building shared infrastructure. Here's what actually happened.
|
|
Yesterday, Anthropic shipped a feature called "interactive tools" in Claude. On the surface, it looks like embedded widgets—Figma boards, Asana timelines, Slack message drafts rendering inside the chat window.
But scroll to the bottom of the announcement and you'll find something unusual: quotes from OpenAI, Microsoft, Block, JetBrains, AWS, and Google DeepMind. All endorsing the same technical specification. All shipping compatible implementations.
That's the real story. Not the feature—the coalition.
|
The Context Gap Problem
MCP (Model Context Protocol) already solved tool connectivity. Your AI can query databases, create calendar events, search documents. The protocol handles authentication, data formats, error handling.
But there's been a persistent gap between what tools can do and what users can see.
Consider a database query that returns 500 rows. The model can summarize the data, but users often want to explore: sort by column, filter by date range, drill into specific records. With text-only responses, every interaction requires another prompt.
"Show me just last week's entries."
"Sort by revenue."
"What's in row 47?"
It works, but it's friction-heavy. The model becomes a middleman for interactions that would take milliseconds in a proper interface.
|
How MCP Apps Actually Works
The architecture relies on two primitives working together.
First, tools can now include a _meta.ui.resourceUri field pointing to a UI resource. Second, servers can expose resources via the ui:// scheme containing bundled HTML and JavaScript.
|
// Tool declaration with UI metadata
{
name: "visualize_data",
description: "Interactive data visualization",
inputSchema: { /* ... */ },
_meta: {
ui: {
resourceUri: "ui://charts/interactive"
}
}
}
|
|
|
When the tool executes, the host client fetches the UI resource, renders it in a sandboxed iframe, and establishes bidirectional communication via JSON-RPC over postMessage.
The critical detail: the model stays in the loop. User interactions propagate back as context updates. Click a chart segment, and the model sees it. Filter a table, and the model knows. This isn't just embedding a web app—it's maintaining a shared state between user, interface, and model.
|
What Developers Can Do With It
The @modelcontextprotocol/ext-apps package provides an App class for UI-to-host communication. The API surface is small but expressive:
|
import { App } from "@modelcontextprotocol/ext-apps";
const app = new App();
await app.connect();
// Receive tool results from the host
app.ontoolresult = (result) => {
renderChart(result.data);
};
// Call server tools from the UI
const response = await app.callServerTool({
name: "fetch_details",
arguments: { id: "123" },
});
// Update model context silently
await app.updateModelContext({
content: [{
type: "text",
text: "User selected region: APAC"
}],
});
|
|
|
Because apps run inside the client, they can do things plain iframes cannot: log events for debugging, open links in the user's browser, send follow-up messages to drive conversation forward, or quietly update model context for later reference. All communication happens over standard postMessage—no framework lock-in.
|
The Security Model
Running UI from MCP servers means executing code you didn't write within your host. This is the obvious concern, and the spec addresses it through four layers:
Iframe sandboxing. All UI content runs in sandboxed iframes with restricted permissions. No direct DOM access to the parent.
Pre-declared templates. Hosts can review HTML content before rendering. Suspicious patterns can be blocked automatically.
Auditable messages. All UI-to-host communication goes through loggable JSON-RPC. Every interaction is traceable.
User consent gates. Hosts can require explicit approval for UI-initiated tool calls.
|
Where This Actually Came From
MCP Apps didn't emerge from a corporate lab. The specification builds on two community efforts that proved the concept at scale.
MCP-UI (mcpui.dev) was created by Ido Salomon and Liad Yosef. They moderated the #ui-wg working group channel where the early patterns were debated, tested, and refined. Many of those patterns are now in the official spec.
OpenAI Apps SDK came from Nick Cooper's work at OpenAI. It proved the model worked at scale in ChatGPT. Enterprises adopted it for production applications.
The collaboration between Anthropic and OpenAI to merge these into a shared standard is the part that matters. These are direct competitors who presumably agree on very little. But they agreed on this.
|
The Coalition
Here's who shipped support or announced plans to:
|
Claude (Anthropic) — Web and desktop, shipped
|
|
ChatGPT (OpenAI) — Rolling out this week
|
|
VS Code (Microsoft) — In Insiders build
|
|
Goose (Block) — Shipped
|
|
JetBrains IDEs — Exploring integration
|
|
Kiro (AWS) — Exploring integration
|
|
Antigravity (Google DeepMind) — Exploring integration
|
For tool developers, this means a single interactive experience that works across competing AI clients without client-specific code. That hasn't existed before.
|
What Shipped in Claude
Nine interactive connectors went live yesterday. These aren't API wrappers—they render functional UI components directly in the conversation:
|
Amplitude
|
Build analytics charts, explore trends, adjust parameters interactively
|
|
Asana
|
Turn conversations into projects, tasks, and visual timelines
|
|
Box
|
Search files, preview documents inline, extract insights
|
|
Canva
|
Create presentation outlines, customize branding in real-time
|
|
Clay
|
Research companies, find contacts, draft personalized outreach
|
|
Figma
|
Generate flow charts, Gantt charts, visual diagrams in FigJam
|
|
Hex
|
Ask data questions, receive interactive charts and tables with citations
|
|
monday.com
|
Manage work, update boards, assign tasks, visualize progress
|
|
Slack
|
Search conversations, generate formatted drafts, review before posting
|
Salesforce integration with Agentforce 360 is listed as "coming soon."
|
Concrete Use Cases
The MCP blog outlines four scenarios where interactive UI makes a material difference over text:
Data exploration. A sales analytics tool returns an interactive dashboard. Users filter by region, drill into accounts, and export reports without leaving the conversation or issuing new prompts.
Configuration wizards. A deployment tool presents forms with dependent fields. Selecting "production" reveals security options; "staging" shows different defaults. The model sees selections in real-time.
Document review. A contract analysis tool displays PDFs inline with highlighted clauses. Users click to approve or flag sections. Decisions propagate to the model immediately.
Real-time monitoring. A server health tool shows live metrics that update as systems change. No re-running the tool to see current status.
|
Developer Resources
The ext-apps repository includes working examples to start from:
threejs-server
3D visualization
|
map-server
Interactive maps
|
pdf-server
Document viewing
|
system-monitor-server
Real-time dashboards
|
sheet-music-server
Music notation
|
Documentation: modelcontextprotocol.io/docs/extensions/apps
SDK: npmjs.com/package/@modelcontextprotocol/ext-apps
Examples: github.com/modelcontextprotocol/ext-apps
Claude Issues: github.com/anthropics/claude-ai-mcp
|
Three Implications Worth Tracking
1. The AI interface becomes the operating system. When users can interact with Figma, Asana, Slack, and Amplitude without leaving the chat window, the AI client starts functioning as a meta-interface layer. Individual apps become plugins. This shifts power toward the platform—whichever AI client captures the user's attention becomes the default entry point for everything else.
2. Competitors are cooperating on infrastructure. Anthropic and OpenAI agreeing on a shared UI standard is unusual. It suggests both see MCP as foundational infrastructure where fragmentation would slow adoption for everyone. The comparison to HTTP or USB isn't hyperbole—this is how protocols become standards.
3. The model stays in the loop. Unlike traditional embedded apps, MCP Apps maintain bidirectional communication with the model. User interactions update context. The AI sees what you're doing and can respond accordingly. This creates a qualitatively different experience from just embedding a web app in a chat window.
|
|
MCP Apps represents the logical next step for the Model Context Protocol—moving from tool execution to tool interaction. But the cross-vendor adoption at launch is the real story. When Anthropic, OpenAI, Microsoft, and Block ship the same spec simultaneously, that's infrastructure becoming standard.
|
|
|
ResearchAudio.io
Technical analysis of AI research. Published when something matters.
|
