Durable Sessions vs CoALA Memory: Which Should You Use?
// TL;DR
Use the IBM CoALA Four-Type Agent Memory Framework if you are designing what your AI agent remembers and learns across sessions. Use the Christensen Durable Sessions AI UX Framework if your AI product's streaming delivery breaks on disconnect, lacks multi-device continuity, or can't support a stop button. These frameworks solve completely different problems — memory architecture vs. real-time delivery infrastructure — and most production AI products will eventually need both.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | IBM CoALA Four-Type Agent Memory Framework |
|---|---|---|
| Best for | Fixing broken streaming UX: disconnects, multi-device sync, live agent control | Designing what an AI agent remembers, learns, and forgets across sessions |
| Core problem solved | Real-time delivery and connection resilience between agents and clients | Agent knowledge persistence, skill execution, and cross-session learning |
| Complexity | High — requires replacing SSE with WebSockets, adding a pub/sub session layer, rearchitecting agent-client communication | Medium — starts as simple as a Markdown file, scales to vector databases and distilled episodic logs |
| Time to apply | Days to weeks — infrastructure-level change to streaming architecture | Hours to days for initial memory audit; weeks for full episodic memory with forgetting policies |
| Prerequisites | An existing AI product with streaming responses (SSE, WebSocket, or polling) and known delivery pain points | An AI agent (or agent design) with a defined task scope; no specific infrastructure required |
| Output type | Redesigned streaming architecture with a Durable Sessions layer, validated against three capability tests | A memory stack declaration (which of four memory types to use) plus implementation and audit recommendations |
| Layer of the stack | Infrastructure / transport layer — sits between agents and clients | Application / cognitive layer — sits inside the agent's reasoning and knowledge system |
| Multi-agent support | Excellent — sub-agents write directly to a shared session, eliminating orchestrator relay bottlenecks | Not directly addressed — focuses on memory within a single agent's architecture |
| Creator background | Mike Christensen (Ably) — real-time infrastructure and streaming delivery specialist | IBM Technology — based on the Princeton CoALA (Cognitive Architectures for Language Agents) research framework |
| When to skip | Skip if your product is non-streaming, batch-only, or has no multi-device or disconnect concerns | Skip if your agent is a stateless reflex bot with no need for persistent knowledge or learning |
What does the Christensen Durable Sessions AI UX Framework do?
The Durable Sessions framework, presented by Mike Christensen of Ably, diagnoses and fixes a specific class of AI product failures: broken streaming delivery. If your AI chat product loses responses when users switch networks, can't show a live response on a second device, or has an ambiguous stop button, this framework explains exactly why and gives you the architecture to fix it.
The core insight is the Single-Connection Trap: most AI products stream responses over a direct HTTP connection (typically SSE via the Vercel AI SDK or similar). When that connection drops, the stream is gone. This one architectural decision prevents three capabilities Christensen identifies as foundational to great AI UX: Resilient Delivery (streams survive disconnects), Continuity Across Surfaces (session follows the user across tabs and devices), and Live Control (clients can steer or cancel an agent mid-generation).
The solution is a Durable Session — a persistent, shared pub/sub channel that sits between the agent layer and the client layer. Agents write events to the session; clients subscribe to the session. Neither holds a direct pipe to the other. This architectural inversion unlocks all three capabilities simultaneously and also solves the orchestrator relay bottleneck in multi-agent systems, where sub-agents can write directly to the session instead of routing updates through a central orchestrator.
What does the IBM CoALA Four-Type Agent Memory Framework do?
The CoALA Memory Framework, based on Princeton's Cognitive Architectures for Language Agents research and presented by IBM Technology, provides a systematic method for designing what an AI agent remembers. It defines four memory types every agent architect should consider:
- Working Memory — the context window; volatile, bounded, always present.
- Semantic Memory — persistent facts, rules, and documentation (e.g., a CLAUDE.md file or vector database).
- Procedural Memory — how the agent does things; a library of skills loaded via progressive disclosure.
- Episodic Memory — distilled records of past sessions and decisions; the hardest to implement correctly.
The framework classifies agents into three tiers. Reflex agents need only working memory. Narrow-purpose agents add procedural memory. Full autonomous agents need all four types. The framework also tackles the forgetting problem — explicitly designing deletion and expiry policies so episodic memory doesn't accumulate stale or contradictory information.
This is a cognitive architecture framework. It lives inside the agent's reasoning system, not in the transport layer.
How do the Durable Sessions and CoALA Memory frameworks compare?
These two frameworks operate at entirely different layers of the AI product stack and solve fundamentally different problems. Comparing them is less about which is "better" and more about understanding that they are complementary.
Durable Sessions is an infrastructure framework. It answers: how do agent-generated events reliably reach the user across connections, devices, and interruptions? It is concerned with transport, delivery, and real-time synchronization. It does not address what the agent knows or how it learns.
CoALA Memory is a cognitive architecture framework. It answers: what should the agent remember, how should it store knowledge, and when should it forget? It is concerned with the agent's internal knowledge and learning systems. It does not address how responses are delivered to the client.
The overlap is minimal. Both frameworks assume you are building a production AI agent product, and both push you to move beyond a fragile demo. But they target different failure modes. A product can have a perfect memory architecture and still break when a user's phone switches from Wi-Fi to cellular. Conversely, a product can have bulletproof streaming delivery and still repeat the same mistakes every session because it has no persistent memory.
Durable Sessions is clearly better for multi-agent coordination at the delivery layer — its pub/sub model lets sub-agents publish updates independently without routing through an orchestrator. CoALA Memory is clearly better for designing what the agent knows and how it learns — it provides a structured taxonomy and tiering system that Durable Sessions doesn't touch.
Which should you choose?
Choose Durable Sessions if your immediate problem is delivery reliability: users losing streamed responses on disconnect, no multi-device session continuity, an ambiguous stop button, or an orchestrator bottleneck in a multi-agent setup. This is the right framework when your agent's intelligence is fine but the user never sees the full output.
Choose CoALA Memory if your immediate problem is agent intelligence: the agent forgets project context between sessions, repeats mistakes, doesn't follow conventions, or you're designing a new agent and need to decide what memory it requires. This is the right framework when your delivery is fine but the agent itself isn't smart enough.
Use both if you are building a production AI product that needs to be both cognitively capable and reliably delivered. Start with whichever addresses your most urgent failure mode. For most teams building their first AI product, memory architecture (CoALA) comes first during agent design, and streaming resilience (Durable Sessions) becomes critical once real users start hitting the product under real-world network conditions.
Neither framework is a substitute for the other. If someone tells you that fixing your streaming layer will make your agent smarter, or that better memory will fix your disconnection problems, they are wrong. These are orthogonal engineering concerns that both deserve explicit architectural attention.
// FREQUENTLY ASKED QUESTIONS
Can I use Durable Sessions and CoALA Memory together?
Yes, and most production AI products should. CoALA Memory designs what the agent knows and remembers. Durable Sessions ensures agent outputs reliably reach users across devices and disconnections. They operate at different stack layers — cognitive vs. infrastructure — and are fully complementary with no conflicts.
Which framework should I start with when building a new AI agent product?
Start with CoALA Memory during the design phase to define your agent's memory stack. Add Durable Sessions when you move to production and real users encounter network drops, multi-device usage, or need live control features like a stop button. Memory architecture comes first conceptually; delivery resilience becomes critical under real-world conditions.
Does the Durable Sessions framework help my agent remember things between sessions?
No. Durable Sessions solves real-time delivery — ensuring streamed responses survive disconnects and sync across devices. It does not address persistent agent memory or cross-session learning. For that, use the CoALA Memory Framework, specifically semantic and episodic memory types.
Does the CoALA Memory Framework fix streaming disconnection issues?
No. CoALA Memory is entirely about the agent's internal knowledge and learning architecture. It does not address transport, streaming, or connection resilience. If users are losing responses on disconnect or can't see live responses on a second device, you need the Durable Sessions framework.
My AI chat app loses responses when users switch from Wi-Fi to cellular. Which framework fixes this?
The Christensen Durable Sessions framework. This is exactly the Single-Connection Trap it diagnoses. You need a Durable Sessions layer that decouples the agent's output stream from the client's connection, allowing automatic resume with no data loss when the network switches.
My AI coding agent keeps forgetting project conventions between sessions. Which framework helps?
The IBM CoALA Memory Framework. Your agent lacks semantic memory — persistent facts and conventions loaded at session start. Implement a project Markdown file (like CLAUDE.md) containing architecture, conventions, and anti-patterns, and load it into the agent's context window at the beginning of every session.
Do I need both frameworks for a simple routing bot?
Probably neither in full. CoALA classifies a simple routing bot as a Tier A reflex agent needing only working memory. Durable Sessions is overkill if the bot returns short, non-streamed responses with no multi-device requirement. Apply these frameworks when your agent's complexity or UX demands warrant them.
How do these frameworks handle multi-agent architectures differently?
Durable Sessions excels here: sub-agents publish updates directly to a shared session channel, eliminating orchestrator relay bottlenecks at the delivery layer. CoALA Memory focuses on memory within a single agent and does not directly address multi-agent coordination. For multi-agent delivery, Durable Sessions is clearly the stronger framework.