Context Graph Agents vs Durable Sessions: Which Should You Use?
// TL;DR
These frameworks solve completely different problems and are complementary, not competing. Use the Neo4j Context Graph framework when your core challenge is making AI agents that reason, decide, and explain their decisions safely. Use the Christensen Durable Sessions framework when your core challenge is delivering agent output reliably across devices, surviving disconnections, and enabling real-time user control. Most production AI products need both: Context Graphs for the decision layer and Durable Sessions for the delivery layer.
// HOW DO THEY COMPARE?
| Dimension | Neo4j Context Graph Decision-Aware Agent Framework | Christensen Durable Sessions AI UX Framework |
|---|---|---|
| Best for | Building agents that make explainable, policy-grounded, auditable decisions | Building resilient, multi-device, real-time AI chat/streaming UX |
| Layer of the stack | Agent reasoning and decision logic layer | Agent-to-client delivery and connectivity layer |
| Core problem solved | Agents guess or act without authority, producing unexplainable, unsafe decisions | Streams break on disconnect, no multi-device support, no live user control |
| Complexity | High — requires graph database (Neo4j), policy encoding, multi-agent separation of analysis and authority | Medium — requires pub/sub infrastructure, WebSocket migration, session state management |
| Time to apply | Weeks to months — policy encoding and domain tuning are substantial | Days to weeks — architectural refactor of streaming layer |
| Prerequisites | Neo4j or equivalent graph database, defined business rules/policies, multi-agent orchestration capability | Pub/sub infrastructure (e.g., Ably, Redis Streams), WebSocket support, existing streaming AI product |
| Output type | Decision traces, alternative proposals, audit logs stored in a context graph | Resilient event streams, resumable sessions, multiplexed agent activity feeds |
| Multi-agent support | Yes — separates analysis agents from decision agents with authority checkpoints | Yes — flattens multi-agent output by having all agents write directly to a shared session |
| Creator background | Andreas Kollegger & Zaid Zaim, Neo4j (graph database company) | Mike Christensen, Ably (real-time infrastructure company) |
| Domain specificity | High-stakes domains: finance, healthcare, autonomous purchasing — anywhere decisions need traceability | Domain-agnostic — any AI product with streaming, chat, or agent-driven UX |
What does the Neo4j Context Graph Decision-Aware Agent Framework do?
The Neo4j Context Graph framework, created by Andreas Kollegger and Zaid Zaim at Neo4j, addresses a specific and critical problem: AI agents that take consequential actions without understanding why they should or shouldn't. It shifts agents from being merely capable (having knowledge) to being decision-aware (having policies, rules, and precedent).
The framework introduces a three-layer memory model — Short-Term Memory (conversation state), Long-Term Memory (persistent world knowledge), and Reasoning Memory (policies, rules, and prior decision rationale). These layers feed into a structured seven-step decision workflow: frame local context, load global context from the graph, validate the reference class, run risk-value analysis, generate an alternatives proposal, check authority and act or escalate, and record the full decision trace.
Two principles stand out. First, Propose, Don't Decide: the analysis agent generates options with pros and cons but never makes the final call — a separate decision agent or human with proper authority does. Second, Act or Escalate — Never Guess: if the agent lacks certainty or authority, it must escalate rather than default to a statistical average that may be catastrophic for edge cases.
This framework is best suited for high-stakes domains like healthcare, finance, and autonomous commerce where decision traceability and accountability are non-negotiable.
What does the Christensen Durable Sessions AI UX Framework do?
The Durable Sessions framework, created by Mike Christensen at Ably, diagnoses why AI chat and agent-driven product experiences feel fragile in production — and the answer is almost never the model. It's the delivery infrastructure.
Christensen identifies three foundational capabilities that separate a demo from a production-grade AI product: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (sessions follow users across tabs and devices), and Live Control (users can steer, interrupt, or cancel agent work mid-stream).
The core architectural concept is a Durable Session — a persistent, stateful, shared resource sitting between agents and clients. Agents write events to the session; clients subscribe to the session. Neither holds a private pipe to the other. This solves the Single-Connection Trap where stream health is fatally coupled to one client's connection health.
The framework also addresses the SSE Resume-Cancel Conflict — SSE's one-way nature makes it impossible to distinguish a network drop (requiring resume) from a user pressing stop (requiring cancel). The solution is bidirectional transport like WebSockets with explicit cancel signals.
For multi-agent architectures, it eliminates the Orchestrator Dual-Purpose Problem by having every sub-agent write directly to the shared session, freeing the orchestrator from relay duties.
How do they compare?
These frameworks operate at entirely different layers of the AI product stack, which is precisely why comparing them reveals their complementary nature rather than a winner.
The Context Graph framework operates at the reasoning and decision layer. It answers: What should the agent decide, and why? It requires a graph database, encoded policies, and domain-specific tuning. Its output is decision traces, alternative proposals, and audit logs. It's high-complexity and domain-specific.
The Durable Sessions framework operates at the delivery and connectivity layer. It answers: How does the agent's output reach the user reliably? It requires pub/sub infrastructure and a transport upgrade. Its output is resilient, resumable, multi-surface event streams. It's medium-complexity and domain-agnostic.
Where they overlap is in multi-agent support. Both frameworks address multi-agent architectures, but from different angles. Context Graphs separate agents by cognitive role (analysis vs. decision authority). Durable Sessions separate agents by communication topology (each agent writes to a shared session independently). A well-architected system uses both patterns.
On complexity and time-to-apply, Durable Sessions is clearly faster to implement — it's an infrastructure refactor, not a domain knowledge engineering project. Context Graphs require significant upfront investment in encoding rules, policies, and precedent, and the framework explicitly warns that it is a skeleton requiring domain tuning.
Which should you choose?
Choose the Context Graph framework if your primary risk is agents making bad, unexplainable, or unauthorized decisions. If you're building in healthcare, financial services, legal tech, or any domain where an autonomous action could cause harm, this framework is essential. The decision trace and escalation mechanics are not optional features in regulated industries — they're requirements.
Choose the Durable Sessions framework if your primary pain is UX fragility — users losing responses on mobile, no multi-device continuity, stop buttons that don't work, or orchestrators buckling under relay duties. If your agent already makes good decisions but the experience of receiving those decisions is broken, this is your framework.
Choose both if you're building a production AI product with consequential agent actions and a real-time multi-surface user experience. The Context Graph framework governs what the agent decides and why. The Durable Sessions framework governs how that decision reaches the user and how the user controls the process. They are complementary by design.
If you're early-stage and must pick one to implement first: start with Durable Sessions. A well-delivered mediocre decision is more recoverable than a brilliant decision that never reaches the user. Then layer in Context Graphs as your agent's autonomy and decision stakes increase.
// FREQUENTLY ASKED QUESTIONS
Can I use Context Graphs and Durable Sessions together?
Yes, and most production AI products should. They operate at different layers of the stack. Context Graphs handle agent reasoning, decision logic, and auditability. Durable Sessions handle how agent output is delivered to users reliably across devices. An agent can make a decision using the Context Graph workflow and publish the result to a Durable Session for resilient delivery.
Do I need Neo4j specifically to use the Context Graph framework?
The framework was designed at Neo4j and uses Cypher as its query language, so Neo4j is the natural fit. However, the core concepts — context graphs, three-layer memory, decision traces, and act-or-escalate checkpoints — could theoretically be implemented on other graph databases. Neo4j provides the most direct path with its Text-to-Cypher tooling for agent integration.
Does the Durable Sessions framework require Ably?
No. The framework describes an architectural pattern based on pub/sub channels with persistence and resumability. Ably is one implementation substrate, but you could build it on Redis Streams, Kafka, or custom WebSocket infrastructure — as long as the session layer is independently addressable, persistent, and fully resumable. Ably simplifies this since it's purpose-built for real-time pub/sub.
Which framework helps with AI agent explainability?
The Neo4j Context Graph framework is clearly better for explainability. Its entire design centers on decision tracing — recording what was considered, what was rejected, the reasoning chain, and the outcome. Every decision creates a stored precedent in the context graph. Durable Sessions does not address explainability; it addresses delivery reliability.
Which framework is faster to implement?
Durable Sessions is significantly faster. It's an infrastructure refactor that can be completed in days to weeks. The Context Graph framework requires weeks to months because you must encode domain-specific policies, rules, and decision precedents into a graph database, design multi-agent authority boundaries, and tune the workflow for your specific domain.
Can the Durable Sessions framework help with multi-agent systems?
Yes. It solves the Orchestrator Dual-Purpose Problem by having each sub-agent write progress updates directly to the shared Durable Session. This eliminates the orchestrator's relay burden and gives clients full multiplexed visibility of all agent activity. However, it does not address agent decision logic or authority — for that, you need the Context Graph framework.
What happens if my AI agent makes a wrong decision with the Context Graph framework?
The framework records a full decision trace — reasoning chain, alternatives considered, and outcome — into the context graph. This creates an auditable record and a precedent that future agents can query. The act-or-escalate principle also reduces wrong decisions by forcing agents to escalate when they lack certainty or authority, rather than guessing.
Is SSE good enough for AI streaming or do I need WebSockets?
SSE is sufficient if you only need one-way streaming with no user control during generation. But if you need a stop button, steering messages, or cancellation, SSE creates an irresolvable ambiguity between disconnect and cancel. The Durable Sessions framework recommends switching to WebSockets or equivalent bidirectional transport for any product requiring live user control.