Durable Sessions vs Software Factory Primitives: Which?
// TL;DR
These frameworks solve different problems and rarely compete. Use the Christensen Durable Sessions Framework when your AI product has broken streaming, disconnection issues, or needs multi-device continuity and live agent control. Use the Bichard Software Factory Primitives Framework when you are orchestrating coding agents across the SDLC and need a coordination layer for task handoff, gating, and scale. If you are building a user-facing AI chat product, start with Durable Sessions. If you are automating software development pipelines with agent swarms, start with Software Factory Primitives.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | Lou Bichard Software Factory Primitives Framework |
|---|---|---|
| Best for | Fixing broken AI chat/streaming UX — disconnections, multi-device, live control | Designing and scaling coding agent pipelines across the SDLC |
| Core problem solved | Agent-to-client delivery resilience and real-time session continuity | Agent-to-agent coordination, task gating, and removing humans from the dev loop |
| Complexity | Moderate — requires replacing SSE with pub/sub session layer and bidirectional transport | High — requires decomposing SDLC into micro-steps, building coordination layer, VM isolation, and harness engineering |
| Time to apply | Days to weeks for an audit and architectural redesign of the streaming layer | Weeks to months to fully implement coordination layer, gates, and harness engineering loop |
| Prerequisites | An existing AI product with a streaming architecture (SSE, WebSocket, etc.) | Existing coding agents (Claude Code, Cursor, custom) and a defined SDLC scope |
| Output type | Redesigned streaming architecture with a durable session layer between agents and clients | A coordination layer with micro-step graphs, gates, runtime decisions, and harness-engineered repos |
| Multi-agent relevance | Solves the orchestrator relay bottleneck — sub-agents write directly to shared sessions | Core focus — defines swarm, fleet, and event patterns for multi-agent coordination |
| Human role | Human is the end user of the AI product experience | Human is incrementally removed from the SDLC loop; on-the-loop, not in-the-loop |
| Creator background | Mike Christensen, Ably — real-time infrastructure and pub/sub expertise | Lou Bichard, Ona — agentic coding pipelines and software factory design |
| Key antipattern identified | The Single-Connection Trap — coupling stream health to one client connection | Using GitHub/Linear as an agent coordination layer — human tools produce agent noise |
What does the Christensen Durable Sessions AI UX Framework do?
Mike Christensen's Durable Sessions framework diagnoses why AI chat experiences break under real-world conditions — network drops, multi-device usage, and the need for users to steer or stop an agent mid-generation. The root cause is what Christensen calls the Single-Connection Trap: the default pattern of streaming LLM responses over a direct HTTP connection (typically SSE) couples the health of the response stream to the health of one client's connection. If that connection drops, the stream is gone.
The framework prescribes introducing a Durable Session — a persistent, stateful, shared resource between the agent layer and the client layer. Agents publish events to the session; clients subscribe to it. Neither holds a private pipe to the other. This single architectural inversion unlocks three foundational capabilities simultaneously: 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).
The framework also identifies the SSE Resume-Cancel Conflict — where closing an SSE connection is ambiguous between a network drop and a user pressing stop — and prescribes switching to bidirectional transport like WebSockets. For multi-agent setups, it solves the Orchestrator Dual-Purpose Problem by having every sub-agent write directly to the session, eliminating the orchestrator's relay role.
What does the Bichard Software Factory Primitives Framework do?
Lou Bichard's Software Factory Primitives framework addresses a fundamentally different problem: how to design and scale systems of coding agents that automate the software development lifecycle. The core insight is that while most infrastructure primitives for agent automation are solved — Runtime (where agents run), Orchestration (scaling agents horizontally), and Triggers (events that bring agents online) — the fourth primitive, Coordination, is almost always missing.
Coordination is the infrastructure that enables agents to hand off work, gate progress through SDLC steps, and collaborate without human intervention. Without it, agents skip steps, lose context, and produce unreliable output. The framework requires decomposing the coarse five-step SDLC (plan, build, test, review, deploy) into explicit micro-steps with machine-checkable gates between them.
Bichard introduces three scale patterns: Swarm (one intent fans out to sub-agents and funnels back into a single PR), Fleet (agents fan across hundreds of repositories), and Events (webhooks trigger agents autonomously). The framework also defines Harness Engineering — the practice of continuously encoding process knowledge back into the repository so agents maintain effectiveness as context windows fill and Context Rot degrades performance.
How do they compare?
These frameworks operate at different layers of the AI stack and solve different categories of problems. Durable Sessions is a delivery and connectivity architecture for user-facing AI products. Software Factory Primitives is a coordination and automation architecture for developer-facing agent pipelines.
Durable Sessions assumes you have an AI product with end users who experience broken streams, lost context on device switches, or inability to control agent output. The fix is architectural: insert a session layer, decouple agents from clients, and switch transports.
Software Factory Primitives assumes you have coding agents that need to execute complex, multi-step development workflows reliably and at scale. The fix is operational and infrastructural: decompose the SDLC, build a coordination layer with gates, choose the right isolation level, and continuously improve agent performance through harness engineering.
Where they do overlap is in multi-agent architecture. Both frameworks recognize that naive approaches to multi-agent communication create bottlenecks. Durable Sessions solves this at the client-delivery level (sub-agents write to a shared session). Software Factory Primitives solves this at the task-coordination level (agents gate and hand off through a coordination layer). In a system that has both user-facing AI and backend coding agents, you might use both frameworks simultaneously at different layers.
Durable Sessions is clearly better for any team whose primary problem is broken streaming UX, disconnection handling, or multi-device continuity. Software Factory Primitives is clearly better for any team whose primary problem is getting coding agents to reliably execute SDLC tasks without human intervention at every step.
Which should you choose?
If you are building or maintaining a user-facing AI chat product — a SaaS assistant, customer support bot, coding assistant with a streaming UI — and your users experience lost responses, broken stop buttons, or can't continue conversations across devices, use the Christensen Durable Sessions Framework. It directly addresses the infrastructure gap between a working demo and a production-quality AI experience.
If you are building a software factory or agentic coding pipeline — automating spec-to-PR workflows, scaling CVE remediation across repositories, or trying to remove humans from repetitive SDLC tasks — use the Bichard Software Factory Primitives Framework. It gives you the vocabulary, patterns, and audit process to identify exactly which infrastructure primitive is missing and how to build it.
If you are building a full-stack AI engineering platform that includes both user-facing AI experiences and backend agent automation, apply both. Use Durable Sessions for the delivery layer between agents and users. Use Software Factory Primitives for the coordination layer between agents and the development pipeline. They are complementary, not competing.
// FREQUENTLY ASKED QUESTIONS
Can I use Durable Sessions and Software Factory Primitives together?
Yes. They operate at different layers. Durable Sessions handles delivery between agents and end users (streaming, resilience, multi-device). Software Factory Primitives handles coordination between coding agents across the SDLC. A platform with both a user-facing AI assistant and backend coding agents would benefit from applying both frameworks simultaneously.
Which framework should I use if my AI chat keeps losing responses on mobile?
Use the Christensen Durable Sessions Framework. Lost responses on mobile are a classic symptom of the Single-Connection Trap — your stream health is tied to one client connection. Introducing a Durable Session layer with automatic resume will solve this without adding complexity to the agent code.
Which framework helps me automate coding agents across hundreds of repos?
Use the Bichard Software Factory Primitives Framework. This is the Fleet pattern — agents fan out across multiple repositories triggered by events or schedules. You will need a coordination layer with micro-step gates to prevent agents from skipping steps at scale, and VM isolation for security.
Do either of these frameworks improve the AI model itself?
No. Both frameworks explicitly focus on infrastructure, not model quality. Christensen's framework improves how model output is delivered to users. Bichard's framework improves how coding agents are coordinated and gated. Both argue that the gap between a demo and a great product is almost entirely in infrastructure.
What is the biggest mistake when building multi-agent AI products?
Both frameworks identify a version of the same mistake: forcing a central component to do too much. Christensen warns against making the orchestrator relay sub-agent updates to clients. Bichard warns against using human tools like GitHub as the agent coordination layer. Both prescribe purpose-built layers to separate concerns.
Is SSE good enough for AI streaming in production?
According to the Durable Sessions framework, no — not if you need live control (stop buttons, steering messages). SSE is one-directional, creating the Resume-Cancel Conflict where closing a connection is ambiguous between a network drop and a user cancel. Bidirectional transport like WebSockets is required for live control.
What is Harness Engineering and does Durable Sessions use it?
Harness Engineering is a concept from the Software Factory Primitives framework — it means encoding process knowledge (agents.md, context files, tests) back into the repository to combat context rot in coding agents. Durable Sessions does not use this concept; it focuses on delivery infrastructure rather than agent context management.
How long does it take to implement each framework?
Durable Sessions can typically be audited and redesigned in days to a few weeks, depending on your existing streaming architecture. Software Factory Primitives takes weeks to months because it requires SDLC decomposition into micro-steps, building a coordination layer, implementing gates, and iterating through harness engineering cycles.