Durable Sessions vs Agent-Ready Engineering: Which Framework?

What does the Christensen Durable Sessions AI UX Framework do?

The Christensen Durable Sessions Framework diagnoses why AI chat experiences break under real-world conditions — network drops, device switching, multi-agent streaming — and provides an architectural solution. The core insight is that most AI products use direct HTTP streaming (typically SSE), which couples the response stream to a single client connection. When that connection drops, the stream is lost.

The framework introduces Durable Sessions: a persistent, shared layer between agents and clients. Agents write events to the session; clients subscribe to it. Neither holds a direct pipe to the other. This unlocks three foundational capabilities: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (sessions follow users across tabs and devices), and Live Control (clients can steer or cancel agents mid-generation).

The framework also identifies the SSE Resume-Cancel Conflict — closing an SSE connection is ambiguous between a disconnect and a user cancel — and argues for bidirectional transport like WebSockets. For multi-agent systems, it solves the Orchestrator Dual-Purpose Problem by letting each sub-agent write directly to the session channel.

What does the Schmid Agent-Ready Engineering Framework do?

The Schmid Agent-Ready Engineering Framework identifies five specific mindset gaps that cause experienced software engineers to build unreliable AI agents, then provides a systematic process for fixing each one.

The five principles are: Text Is Our New State (replace Boolean flags with semantic context), Hand Over Control (define goals, not step-by-step workflows), Errors Are Just Inputs (feed failures back to the model instead of restarting), Move From Unit Tests to Evals (measure reliability across runs, not exact outputs), and Agents Evolve and APIs Don't (make every tool self-documenting for zero-context callers).

This framework is particularly powerful for senior engineers who default to traditional deterministic patterns. It reframes the engineer's role from traffic controller to dispatcher — you specify the destination and available options, then trust the LLM to navigate.

How do they compare?

These frameworks operate at fundamentally different layers of the AI product stack and are complementary, not competing.

The Christensen framework operates at the infrastructure and delivery layer. It assumes your agent produces good outputs but the experience of receiving those outputs is fragile. It is an architecture-heavy solution requiring pub/sub infrastructure, session management, and transport protocol changes.

The Schmid framework operates at the agent logic and development process layer. It assumes your agent itself is the problem — producing unreliable results, fighting the model with rigid workflows, or using poorly documented tools. It is a mindset-plus-refactoring solution that changes how you design prompts, handle errors, write tools, and test.

Where they overlap is in the shared belief that demo-quality is not production-quality. Christensen calls the gap a "fragile demo"; Schmid calls it the reliability threshold that must be met before shipping. Both reject the idea that model improvements alone will solve product problems.

Key differences:

- Christensen is model-agnostic — it does not care what LLM you use. Schmid is model-aware and explicitly plans for model replacement with the "build to delete" principle.

- Schmid is faster to apply — rewriting prompts, tool docs, and tests can happen in hours. Christensen requires infrastructure deployment that takes days or weeks.

- Christensen is clearly better for multi-agent delivery — it directly solves the orchestrator relay bottleneck. Schmid improves individual agents but does not address how their outputs reach the client.

- Schmid is clearly better for agent reliability — if your agent makes wrong decisions, no amount of Durable Sessions will fix it.

Which should you choose?

Start with the Schmid Agent-Ready Engineering Framework if your agent itself is unreliable. If outputs are wrong, workflows are brittle, tools are poorly documented, or your test suite asserts exact outputs and constantly fails — these are agent-layer problems. Schmid gives you the diagnostic and fix for each one.

Move to the Christensen Durable Sessions Framework once your agent works correctly but the user experience breaks. If users lose responses on mobile, cannot continue conversations across devices, cannot press stop without losing their place, or your multi-agent orchestrator is drowning in relay logic — these are delivery-layer problems. Christensen gives you the architectural pattern.

If you are building a new AI product from scratch, apply Schmid's principles during agent development and Christensen's architecture during infrastructure design. They compose naturally: Schmid ensures the agent produces reliable outputs; Christensen ensures those outputs reach every client, on every device, without loss.

The one exception: if you are specifically building a multi-agent system where sub-agent visibility and real-time progress streaming are core UX requirements, prioritize the Christensen framework early — the architectural decisions it addresses are hard to retrofit.

Can you use both frameworks together?

Yes, and you should. The Schmid framework ensures your agents are reliable, goal-oriented, and properly tested. The Christensen framework ensures those reliable agents deliver their outputs through a resilient, multi-surface, controllable infrastructure. Applying Schmid without Christensen gives you a great agent with a fragile delivery pipe. Applying Christensen without Schmid gives you a beautifully resilient delivery pipe for unreliable outputs. The combination is what separates production-grade AI products from demos.