Durable Sessions vs Agent Interface Engineering: Which?
// TL;DR
Choose the Christensen Durable Sessions Framework if your AI product suffers from dropped streams, no multi-device support, or lack of user control over running agents — it fixes the delivery layer between agents and clients. Choose the Hablich Agent Interface Engineering Framework if agents are calling wrong tools, burning excessive tokens, or failing tasks because your MCP tool descriptions and data payloads are poorly designed — it fixes the interface layer agents consume. Most teams building chat-style AI products hit delivery problems first; most teams building tool-using agentic systems hit interface problems first. They solve different layers and can be used together.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | Hablich Agent Interface Engineering Framework |
|---|---|---|
| Best for | AI chat products and agent-driven experiences where streaming, reconnection, and multi-device continuity break under real-world conditions | MCP servers, CLI tools, and agent-facing APIs where agents select wrong tools, waste tokens on raw data, or fail to complete tasks |
| Problem layer addressed | Delivery and connectivity layer — how agent output reaches the client | Interface and tool design layer — how agents discover, select, and consume tools |
| Core metric | Resilience: stream survives disconnects, multi-surface sync, live control works | Fuel efficiency: tokens per successful outcome per user journey |
| Complexity to implement | High — requires replacing streaming infrastructure, introducing pub/sub session layer, and potentially swapping SSE for WebSockets | Medium — primarily requires auditing tool descriptions, restructuring data payloads, and adding measurement instrumentation |
| Time to apply | Days to weeks — architectural change to streaming and session management | Hours to days — description rewrites and payload restructuring can start immediately; measurement takes longer |
| Prerequisites | Existing AI streaming product, understanding of SSE/WebSocket transports, access to pub/sub infrastructure | Existing MCP server or agent-facing tool inventory, access to token usage data, defined user journeys |
| Output type | Redesigned streaming architecture with a persistent Durable Sessions layer decoupling agents from clients | Optimised tool inventory with audited descriptions, semantic summaries, trust tier classification, and per-journey fuel efficiency metrics |
| Security model | Not a primary focus — addresses reliability and UX, not trust boundaries | First-class concern — explicit three-tier trust model (local dev, CI, internet-facing) with friction-by-design for consent |
| Multi-agent support | Strong — directly solves the orchestrator relay bottleneck by letting all sub-agents write to a shared session | Indirect — improves individual tool interfaces that any agent consumes, but does not address inter-agent communication patterns |
| Creator background | Mike Christensen (Ably) — real-time infrastructure and pub/sub messaging specialist | Michael Hablich (Google) — Chrome DevTools engineer applying browser tooling principles to agent interface design |
What does the Christensen Durable Sessions AI UX Framework do?
The Christensen Durable Sessions Framework diagnoses and fixes a specific class of AI product failures: the ones caused by coupling your agent's response stream to a single client connection. Mike Christensen calls this the Single-Connection Trap, and it is the default state of any product using SSE-based streaming (including the Vercel AI SDK, LangChain streaming, and similar toolchains).
The framework identifies three foundational capabilities every production AI experience needs: Resilient Delivery (streams survive disconnects), Continuity Across Surfaces (sessions follow users across tabs and devices), and Live Control (users can steer, interrupt, or cancel agents mid-generation). It then prescribes a specific architectural pattern — Durable Sessions — where a persistent, stateful pub/sub channel sits between agents and clients. Agents write events to the session; clients subscribe to it. Neither holds a direct pipe to the other.
This solves the SSE Resume-Cancel Conflict (where closing a connection is ambiguous between "I disconnected" and "I pressed stop"), eliminates the Orchestrator Dual-Purpose Problem (where the orchestrator is forced to relay sub-agent progress), and makes adding new capabilities like push notifications or human-agent handoff straightforward.
What does the Hablich Agent Interface Engineering Framework do?
The Hablich Agent Interface Engineering Framework addresses a completely different failure class: agents that can't effectively use the tools you've given them. Michael Hablich, drawing from Google's Chrome DevTools work, treats agents as a different user class from humans — same goals, different bottlenecks. Where humans need visual clarity, agents need token efficiency and clear discoverability.
The framework provides a systematic process for auditing and improving MCP servers, CLI tools, and agent-facing APIs. It starts with trust tier classification (local dev vs. CI vs. internet-facing), maps target user journeys, and then attacks the most common failure modes: raw data dumps that blow context windows (the Dump Zone), monolithic tools that agents can't decompose, tool descriptions with quality smells that cause wrong tool selection, and vague error messages that prevent self-healing.
The core metric is tokens per successful outcome — measured per user journey, never aggregated globally. The framework includes concrete patterns like Slim Mode (minimal tool sets for cost-sensitive deployments), semantic summaries (structured markdown instead of raw payloads), proactive detours (redirecting agents away from wrong tools), and diagnostic playbooks (enabling self-healing on known failure modes).
How do they compare?
These frameworks operate at different layers of the AI product stack and are complementary, not competing.
The Durable Sessions Framework works at the delivery layer — the infrastructure between agent output and client display. It assumes your agents are producing useful output but that output is getting lost, fragmented, or locked to a single connection. The problems it solves are architectural: you need to replace your streaming transport, introduce a session substrate, and potentially swap SSE for WebSockets.
The Agent Interface Engineering Framework works at the interface layer — the tool schemas, descriptions, and data formats that agents consume to do their work. It assumes your delivery infrastructure is functional but your agents are failing because they're selecting wrong tools, drowning in raw data, or burning tokens on retries. The problems it solves are primarily design and measurement problems: rewrite descriptions, restructure payloads, add instrumentation.
On security, Hablich's framework is clearly stronger — it provides an explicit three-tier trust model and treats friction as a security feature. Christensen's framework does not address trust boundaries. On multi-agent architectures, Christensen's framework is clearly stronger — it directly solves the orchestrator relay bottleneck that Hablich's framework does not address.
Implementation complexity differs significantly. Durable Sessions requires infrastructure-level changes (pub/sub layer, transport replacement, session management). Agent Interface Engineering can start with description rewrites and payload restructuring — changes you can ship in hours, not weeks.
Which should you choose?
If you are building a chat-style AI product where users interact with streaming responses — and you're seeing problems with dropped connections, no multi-device support, or inability to cancel/steer running agents — start with the Durable Sessions Framework. Your problem is in the delivery layer.
If you are building or maintaining an MCP server, CLI tool, or agent-facing API — and agents are calling wrong tools, blowing context windows on raw data, or failing to complete tasks — start with the Agent Interface Engineering Framework. Your problem is in the interface layer.
If you are building a full agentic product with both user-facing chat and tool-using agents behind the scenes, you likely need both. Apply the Agent Interface Engineering Framework first (it's faster to implement and will surface immediate wins in tool selection and token costs), then layer on Durable Sessions when you need production-grade delivery resilience.
The key insight is that these frameworks address Mike Christensen's own observation from a different angle: "the gap between a fragile demo and a great AI product experience is almost entirely in the infrastructure, not the model." Christensen locates that infrastructure gap in the streaming delivery layer. Hablich locates it in the tool interface layer. Both are right — they're just looking at different parts of the stack.
// FREQUENTLY ASKED QUESTIONS
Can I use Durable Sessions and Agent Interface Engineering together?
Yes, and most mature agentic products should. They solve different layers of the stack — Durable Sessions fixes delivery between agents and clients, while Agent Interface Engineering fixes how agents discover and use tools. Apply Agent Interface Engineering first for quick wins on tool selection and token costs, then add Durable Sessions for production-grade streaming resilience.
Which framework should I use if my AI chat keeps losing responses when users switch networks?
The Christensen Durable Sessions Framework. This is exactly the Single-Connection Trap it diagnoses. You need a persistent session layer between your agent and client so the stream survives disconnections. The agent writes to the session; the client reconnects and resumes from where it left off without agent-side replay logic.
Which framework helps reduce token costs when agents use MCP tools?
The Hablich Agent Interface Engineering Framework. It directly targets token efficiency through semantic summaries (replacing raw data dumps), tool categorisation (hiding niche tools from default context), Slim Mode (minimal tool sets), and improved descriptions that reduce wrong tool calls. Its core metric — tokens per successful outcome — is purpose-built for this problem.
Do I need Durable Sessions if I'm already using WebSockets instead of SSE?
Possibly yes. WebSockets give you bidirectional communication (solving the Resume-Cancel Conflict), but they do not automatically give you session persistence, multi-device continuity, or shared visibility across clients. A Durable Sessions layer is still needed for those capabilities. WebSockets are a necessary transport upgrade, not a complete solution.
How does Hablich's framework handle security for agentic systems?
It uses a three-tier trust model. Tier 1 (local dev) requires human consent at every sensitive action. Tier 2 (CI) requires data isolation via containers and separate profiles. Tier 3 (internet-facing agents) requires domain allow lists and prompt injection mitigations. Tools can be shared across tiers, but security models must never be shared. Friction is treated as a security feature, not a UX problem.
Which framework is better for multi-agent architectures with an orchestrator?
The Christensen Durable Sessions Framework is clearly better for this. It directly solves the Orchestrator Dual-Purpose Problem where orchestrators are forced to relay sub-agent updates. With Durable Sessions, each sub-agent writes directly to a shared session channel, freeing the orchestrator to focus on coordination only. Hablich's framework improves individual tool interfaces but doesn't address inter-agent communication.
What is the fastest way to improve my MCP server's performance with agents?
Start with Hablich's framework, Steps 3 and 5: replace raw data responses with semantic summaries, and audit every tool description for clear purpose and activation criteria. These changes can be implemented in hours and typically produce immediate improvements in tool selection accuracy and token efficiency. Add measurement instrumentation next to track tokens per successful outcome.
Is the Durable Sessions pattern the same as using Redis for message buffering?
No. Redis buffering is a partial fix that keeps replay logic inside the agent, increasing agent complexity. Durable Sessions is an architectural inversion: the session layer handles persistence, replay, and reconnection independently. The agent only writes events to the session and never manages connection state. This is the key principle of agent-client decoupling that Redis buffering alone does not achieve.