Durable Sessions vs MCP Apps: Which AI UX Framework?
// TL;DR
Choose Durable Sessions if you're building a production AI chat product that needs resilient streaming, multi-device continuity, or real-time agent control. Choose MCP Apps if you're a developer building MCP server tools that need rich interactive UI inside VS Code's chat window. These frameworks solve fundamentally different problems: Durable Sessions fixes the delivery and connectivity layer of AI products at scale, while MCP Apps replaces plain-text tool outputs with interactive HTML components inside developer IDEs. Most teams building customer-facing AI products need Durable Sessions first.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | MCP Apps Interactive UI Builder (VS Code) |
|---|---|---|
| Best for | Production AI chat products needing resilient, multi-device streaming | Developer tools rendering rich interactive UI inside VS Code chat |
| Problem solved | Broken streams, lost responses on disconnect, no cross-device continuity, no live agent control | MCP tools returning plain text or ASCII art instead of interactive visual components |
| Complexity | High — requires architectural redesign of streaming layer, pub/sub infrastructure, transport swap | Moderate — requires building bundled HTML UI, wiring MCP resource references, configuring invoker modes |
| Time to apply | Days to weeks depending on existing architecture | Hours to days per MCP App tool |
| Prerequisites | Existing AI chat/agent product, understanding of SSE/WebSocket streaming, pub/sub infrastructure | MCP server, VS Code with GitHub Copilot, front-end framework knowledge (React/Vue/Svelte) |
| Output type | Architectural redesign — resilient session layer between agents and clients | Interactive HTML components rendered in sandboxed iFrames inside chat |
| Target audience | Backend/infra engineers and AI product architects building customer-facing products | Developers building MCP server tools for IDE-based AI assistants |
| Multi-agent support | Excellent — sub-agents write directly to shared session, eliminating orchestrator relay bottleneck | Not addressed — focused on single-tool UI rendering |
| Creator background | Mike Christensen, Ably (real-time infrastructure platform) | Marlene Mhangami & Liam Hampton, GitHub |
| Transport model | Replaces SSE with bidirectional WebSockets + persistent pub/sub channels | Uses MCP protocol resource references to trigger iFrame rendering in host |
What does the Durable Sessions AI UX Framework do?
The Christensen Durable Sessions Framework diagnoses and fixes the most common failure modes in AI chat product architectures. It identifies the Single-Connection Trap — the default pattern where your AI response stream is coupled to one client's HTTP connection. When that connection drops (network switch, mobile background, tab close), the stream dies.
The framework introduces a Durable Sessions layer between your agent layer and your client layer. Agents write events to a persistent, shared session channel. Clients subscribe to that channel. Neither party holds a direct connection to the other. This architectural inversion unlocks three foundational capabilities simultaneously: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (session follows users across tabs and devices), and Live Control (clients can steer, interrupt, or cancel agents mid-generation).
A key insight is the SSE Resume-Cancel Conflict: when using Server-Sent Events, closing a connection is ambiguous — it could mean the network dropped or the user pressed stop. These are mutually exclusive behaviors under SSE, which is why the framework mandates bidirectional transport like WebSockets for live control scenarios.
For multi-agent architectures, the framework solves the Orchestrator Dual-Purpose Problem by having every sub-agent write directly to the session channel, eliminating the orchestrator's relay role.
What does the MCP Apps Interactive UI Builder do?
The MCP Apps Interactive UI Builder transforms MCP server tools from returning plain text into rendering fully interactive HTML components directly inside the chat window of VS Code or another MCP host. Instead of getting ASCII art flame graphs or text-based product listings, users see real interactive charts, diagrams, checkout flows, and dashboards — all rendered in a sandboxed iFrame.
Every MCP App follows a three-part architecture: the Tool (the LLM-callable capability), the Resource (a bundled HTML UI), and the Link (the resource reference that tells the host to render the iFrame). The framework supports bidirectional live interaction where the iFrame UI calls back to the MCP server for fresh data, enabling real-time updates without typing new prompts.
The framework also introduces invoker modes that control whether the LLM, the iFrame app, or both can trigger tool calls. Security is enforced through sandboxed iFrame isolation — the app cannot touch VS Code settings, external APIs, or the file system.
How do they compare?
These frameworks operate at completely different layers of the AI product stack and are not substitutes for each other.
Durable Sessions is an infrastructure-level architectural pattern for any AI product that streams responses to users. It redesigns how agents and clients communicate, introducing a persistent session substrate that solves connectivity, multi-device, and control problems. It is platform-agnostic and applies to web apps, mobile apps, and any client surface.
MCP Apps is a UI rendering pattern specific to the MCP protocol ecosystem, primarily targeting VS Code with GitHub Copilot. It solves the problem of tool outputs being limited to plain text by enabling rich, interactive HTML components inside the chat. It does not address streaming resilience, multi-device continuity, or agent control.
Durable Sessions is clearly the higher-complexity, higher-impact framework. It requires rethinking your streaming architecture, introducing pub/sub infrastructure, and potentially replacing SSE with WebSockets. MCP Apps is more targeted and faster to implement — you build a bundled HTML UI, wire the resource reference, and register the server.
Durable Sessions is better for multi-agent architectures. MCP Apps does not address multi-agent coordination at all.
MCP Apps is better for developer tooling scenarios where the goal is to replace text-based MCP tool outputs with interactive visuals. Durable Sessions does not address tool output rendering.
Which should you choose?
Choose Durable Sessions if you are building a customer-facing AI chat product and any of the following are true: users lose responses when switching networks, users cannot see live responses on a second device, your stop button is unreliable or ambiguous, your orchestrator is bogged down relaying sub-agent updates, or your agent code contains reconnection and replay logic. This is the framework that closes the gap between a fragile demo and a production-grade AI experience.
Choose MCP Apps if you are building developer tools within the MCP ecosystem and your MCP server tools return data that would be dramatically better as interactive visual components — flame graphs, architecture diagrams, dashboards, or branded product UIs — rendered directly inside VS Code's chat window.
Choose both if you are building an MCP-based platform where the interactive UI components (MCP Apps) are delivered to users through a streaming architecture that needs to be resilient and multi-surface (Durable Sessions). They are complementary, not competing.
For most teams building AI products today, the streaming and connectivity layer is the more urgent problem. Model quality gets all the attention, but the delivery infrastructure is where most AI UX breaks. Start with Durable Sessions.
// FREQUENTLY ASKED QUESTIONS
Can I use Durable Sessions and MCP Apps together?
Yes. They solve different problems and are fully complementary. Durable Sessions handles the streaming delivery and connectivity layer, while MCP Apps handles rich UI rendering for MCP tool outputs. A platform could use Durable Sessions for resilient multi-device delivery and MCP Apps for interactive tool components within that delivery layer.
Do I need Durable Sessions if I'm only building tools for VS Code?
Probably not. If your users are developers interacting with MCP tools inside VS Code's chat, MCP Apps is the right framework. Durable Sessions solves problems like network disconnections, multi-device continuity, and live agent control that are more relevant to customer-facing AI chat products than single-user IDE extensions.
Does MCP Apps work outside of VS Code?
MCP Apps render on any MCP host that supports UI resource references and sandboxed iFrame rendering. Currently, VS Code with GitHub Copilot is the primary supported host. The pattern is host-dependent — if your MCP host does not support iFrame rendering, the app falls back to plain text.
Why can't I just use SSE with reconnection logic instead of Durable Sessions?
SSE has a fundamental limitation: closing a connection is ambiguous between a network disconnect (requiring resume) and a user cancel (requiring termination). You cannot support both resume and cancel reliably over SSE. Durable Sessions with bidirectional transport like WebSockets resolves this conflict by using explicit signals for each action.
What infrastructure do I need for Durable Sessions?
You need a pub/sub channel layer that supports persistent, independently addressable, and fully resumable channels — such as Ably, or a self-built equivalent using Redis Streams or similar. You also need bidirectional transport (WebSockets) if live control is required. The agent layer writes to channels; clients subscribe to them.
Can MCP Apps handle real-time data updates without the user typing new prompts?
Yes. MCP Apps support bidirectional live interaction where the iFrame UI calls back to the MCP server, the server returns fresh data, and the app re-renders. This callback loop enables real-time interactivity — clicking filters, updating charts, completing checkout flows — all without typing new chat messages.
Which framework is harder to implement?
Durable Sessions is significantly harder. It requires an architectural redesign of your streaming layer, introducing pub/sub infrastructure, potentially replacing SSE with WebSockets, and restructuring how agents emit events. MCP Apps can be implemented in hours to days per tool — you build a bundled HTML UI, wire the resource reference, and register the server.
Is Durable Sessions specific to any vendor or platform?
The concept is platform-agnostic and applies to any AI product that streams responses to clients. The framework originates from Mike Christensen at Ably, and Ably's pub/sub infrastructure is a natural implementation substrate, but the architectural pattern can be implemented with any persistent pub/sub channel system.