Context Engine vs Durable Sessions: Which Should You Use?
// TL;DR
Choose the Unblocked Context Engine Framework if your AI coding agents write architecturally wrong code despite having data access — it fixes the knowledge problem. Choose the Christensen Durable Sessions Framework if your AI-powered product breaks when users disconnect, switch devices, or need to interrupt a streaming response — it fixes the delivery problem. These frameworks solve fundamentally different layers of the AI stack and are complementary, not competing.
// HOW DO THEY COMPARE?
| Dimension | Unblocked Context Engine Framework | Christensen Durable Sessions AI UX Framework |
|---|---|---|
| Best for | Engineering teams whose AI coding agents produce compilable but architecturally wrong code due to missing organizational context | Product teams whose AI chat or agent UX breaks under real-world network conditions, multi-device use, or user-initiated interrupts |
| Problem layer | Knowledge and reasoning layer — what the agent knows before it acts | Delivery and connectivity layer — how agent output reaches the user reliably |
| Complexity | High — requires ingesting multiple data sources, building a social graph from git history, implementing exhaustive retrieval, and conflict resolution logic | Medium — requires replacing direct streaming with a pub/sub session layer and switching from SSE to WebSockets for bidirectional control |
| Time to apply | Weeks to months — data ingestion, social graph construction, retrieval pipeline, and conflict resolution all require iterative development | Days to weeks — architectural refactor of the streaming layer with well-understood pub/sub patterns and available infrastructure (e.g., Ably, Redis Streams) |
| Prerequisites | Access to code repositories, corporate knowledge corpus (Slack, docs, tickets), and ideally git/PR history for social graph construction | An existing AI product with streaming responses; understanding of current transport (SSE, WebSocket); clarity on target surfaces (web, mobile, multi-tab) |
| Output type | Token-optimized research packets delivered to agents before execution; also answers surfaced in Slack channels, ticket triage, and incident management | A persistent Durable Sessions layer that agents write to and clients subscribe to, enabling resilient delivery, cross-surface continuity, and live control |
| Primary user | AI/platform engineers building or managing AI coding agents and headless agent pipelines | Product engineers and AI UX designers building consumer- or enterprise-facing AI chat products |
| Creator background | Unblocked (AI developer tooling company focused on organizational context for agents) | Mike Christensen, Ably (real-time infrastructure company specializing in pub/sub and WebSocket delivery) |
| Key anti-pattern addressed | Satisfaction of Search — agent stops retrieving at first plausible hit and misses the correct organizational pattern | Single-Connection Trap — stream health is coupled to one client connection, breaking on disconnect, multi-device, or cancel |
| Complementary use | Works upstream of Durable Sessions — ensures the agent produces correct output that the delivery layer then transports | Works downstream of the Context Engine — ensures correct agent output actually reaches the user reliably across all surfaces |
What does the Unblocked Context Engine Framework do?
The Unblocked Context Engine Framework solves a specific and costly problem: AI coding agents that have access to your data but lack understanding of your organization. When you connect an agent to your codebase, docs, and Slack via MCPs or pipes, the agent can retrieve information — but it behaves like a day-one engineer. It does not know your factory patterns, shared service libraries, or the CTO's Slack clarification that overrides an outdated doc. The result is code that compiles, passes tests, and gets rejected by a senior engineer because it ignores existing architecture.
The framework introduces a Context Engine — a system that ingests your full organizational knowledge corpus (code, docs, Slack, tickets, runbooks), builds a social graph of engineers from commit and PR history, performs exhaustive retrieval scoped by the requester's identity, resolves conflicts between contradictory sources, and compresses everything into a token-optimized research packet. This packet is delivered to the agent before it begins execution. The framework follows a Context Ladder progression: from humans manually feeding context (stage 1), to static files like CLAUDE.md (stage 2), to a fully dynamic, personalized context engine (stage 3). The goal is stage 3, where agents can run headlessly without human babysitting.
The Context Engine is not just for coding agents. The same engine serves Slack ask-engineering channels, ticket triage, incident management, and code review — multiplying the investment across every surface that needs organizational knowledge.
What does the Christensen Durable Sessions Framework do?
The Christensen Durable Sessions Framework diagnoses and fixes the delivery layer of AI-powered products. Most AI chat products use direct HTTP streaming (typically SSE via the Vercel AI SDK or similar). This creates the Single-Connection Trap: the response stream is a private pipe between one client and the agent. If the connection drops, the stream is lost. A second tab or device cannot see the live response. And SSE's one-way nature creates an irresolvable ambiguity — closing the connection could mean the user disconnected (please resume) or pressed stop (please cancel).
The framework introduces Durable Sessions: a persistent, stateful, shared layer between agents and clients. Agents write events (token chunks, tool call results, status updates) to a session channel. Clients subscribe to that channel. Neither holds a direct reference to the other. This architectural inversion simultaneously 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, interrupt, or cancel agents mid-generation via bidirectional transport).
For multi-agent architectures, Durable Sessions also solve the Orchestrator Dual-Purpose Problem — instead of forcing the orchestrator to relay sub-agent progress updates, each sub-agent writes directly to the session, and clients see all concurrent activity through a single subscription.
How do they compare?
These two frameworks operate on entirely different layers of the AI product stack, and comparing them head-to-head on the same axis would be misleading.
The Context Engine Framework is about what the agent knows. It ensures the agent produces the right output — architecturally correct, org-aware, mergeable code. It operates at the planning and reasoning phase, before any output is generated.
The Durable Sessions Framework is about how agent output reaches the user. It ensures that once the agent produces output, it arrives reliably, survives network disruptions, works across devices, and can be steered by the user in real time. It operates at the delivery and connectivity phase, after output is being generated.
A team building AI coding agents for internal use (headless, background agents) will get enormous value from the Context Engine and may never need Durable Sessions. A team building a consumer-facing AI chat product may need Durable Sessions urgently but have no use for the Context Engine's social graph and organizational retrieval. A team building a sophisticated AI product with both intelligent agents and a polished multi-surface UX will eventually need both.
The Context Engine Framework is significantly more complex to implement — it requires ingesting heterogeneous data sources, constructing a social graph, building exhaustive retrieval pipelines, and implementing conflict resolution. Durable Sessions, while a meaningful architectural refactor, follows well-understood pub/sub patterns and can be implemented with existing real-time infrastructure.
Which should you choose?
Choose the Unblocked Context Engine Framework if:
- Your AI coding agents write code that compiles but gets rejected in code review for architectural reasons
- You are manually pointing agents to the right files, correcting doom loops, or re-feeding context every session
- You are planning to move toward headless or background agents that must operate without human supervision
- You have 10+ engineers and a meaningful amount of tribal knowledge spread across Slack, docs, and code
Choose the Christensen Durable Sessions Framework if:
- Your AI product's streaming responses break when users switch networks, tabs, or devices
- You need a stop button that works reliably without killing resume capability
- You have multiple agents whose progress you want to show to users in real time
- You are building a customer-facing AI experience where UX polish and reliability directly affect retention
Choose both if you are building a full-stack AI product where agents need organizational intelligence and users need a resilient, multi-surface experience. Implement the Context Engine to ensure agents produce correct output, and Durable Sessions to ensure that output reaches users reliably. They are complementary layers, not alternatives.
// FREQUENTLY ASKED QUESTIONS
Can I use the Context Engine Framework and Durable Sessions Framework together?
Yes, and for full-stack AI products you should. The Context Engine ensures your agent produces correct, org-aware output by solving the knowledge problem. Durable Sessions ensure that output reaches users reliably across devices and network conditions by solving the delivery problem. They operate on different layers and complement each other directly.
Do I need Durable Sessions if I'm only building internal AI coding agents?
Probably not. If your agents run headlessly in the background (CI pipelines, background task runners) without a real-time user-facing chat interface, Durable Sessions solve a problem you don't have. Focus on the Context Engine Framework to ensure agent output quality. Durable Sessions become relevant when you add a user-facing streaming interface.
Does the Context Engine Framework replace RAG?
It replaces naive RAG — the pattern of dropping documents into a vector store and letting the agent search. The framework uses targeted, exhaustive retrieval scoped by a social graph, with explicit conflict resolution. It still retrieves information, but the retrieval strategy is fundamentally different from standard RAG implementations that suffer from satisfaction of search.
Can Durable Sessions work with SSE or do I have to switch to WebSockets?
Durable Sessions can use SSE for the downstream direction (agent to client), but if you need Live Control — stop buttons, steering messages, or mid-generation follow-ups — you must add a bidirectional transport like WebSockets. SSE alone cannot distinguish a user cancel from a network disconnect, making resume and cancel mutually exclusive.
How long does it take to implement the Context Engine Framework?
Weeks to months, depending on your organization's size and data source complexity. You need to ingest code repositories, corporate knowledge sources (Slack, docs, tickets), build a social graph from git and PR history, implement exhaustive retrieval, and add conflict resolution. The Durable Sessions Framework is faster — days to weeks — because it follows established pub/sub infrastructure patterns.
What is the Context Ladder and where is my team on it?
The Context Ladder has three stages: (1) you manually feed context to agents every session, (2) you maintain static files like CLAUDE.md that agents read, (3) you have a dynamic context engine with personalized, runtime-aware retrieval. Most teams are at stage 1 or 2. The Unblocked Context Engine Framework is designed to move you to stage 3.
What is the Single-Connection Trap in AI streaming?
The Single-Connection Trap is when your AI product streams responses over a direct HTTP connection (typically SSE) between one client and the agent. If that connection drops, the stream is lost. A second device cannot see the response. And closing the connection is ambiguous between disconnect and cancel. The Durable Sessions Framework eliminates this by routing all communication through a persistent shared session layer.
Which framework should I prioritize if I have limited engineering resources?
Prioritize based on your primary pain point. If your agents produce wrong code that wastes senior engineer review time, the Context Engine has higher ROI. If your users complain about lost responses, broken stop buttons, or inability to switch devices mid-conversation, Durable Sessions has higher ROI. Neither framework solves the other's problem.