Durable Sessions vs Disposable Agent Orchestration: Which?
// TL;DR
Choose Durable Sessions if your core problem is broken AI chat UX — dropped streams, no multi-device continuity, or no stop button. Choose Disposable Agent Orchestration if your problem is scaling many autonomous coding agents across high-volume tasks on Kubernetes. These frameworks solve different layers of the AI product stack: Durable Sessions fixes the real-time delivery layer between agents and users, while Disposable Agent Orchestration fixes the compute and workflow layer that runs agents at scale. Most teams building a user-facing AI chat product should start with Durable Sessions.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | Solmaz On-Demand Disposable Agent Orchestration Framework |
|---|---|---|
| Best for | Fixing broken AI chat UX: dropped streams, multi-device gaps, no live control | Scaling autonomous coding agents across high-volume tasks (PRs, bugs, issues) on Kubernetes |
| Core abstraction | Durable Session — a persistent pub/sub channel between agents and clients | On-demand disposable agent pod — one ephemeral Kubernetes pod per task |
| Primary layer addressed | Real-time delivery and connectivity (agent-to-client transport) | Compute orchestration and workflow automation (agent lifecycle and task routing) |
| Complexity to implement | Medium — requires replacing SSE with bidirectional transport and adding a session/pub-sub layer | High — requires Kubernetes cluster, ACP adapters, state sync, operator setup, and SOP encoding |
| Time to apply | Days to weeks for a streaming architecture migration | Weeks to months including infra, workflow design, and platform integrations |
| Prerequisites | Existing AI chat/agent product with streaming responses; familiarity with WebSockets or pub/sub | Kubernetes cluster, agent harnesses (Codex/Claude Code), chat platform (Slack/Discord), ACP tooling |
| Output type | Resilient, multi-surface, controllable real-time AI chat experience | Automated, parallelised agent workflows producing code changes, PR reviews, and triaged issues |
| Multi-agent support | Yes — multiple agents write to one shared session, eliminating orchestrator relay bottleneck | Yes — multiple disposable agent pods run concurrently, each on its own task channel |
| Creator background | Mike Christensen, Ably (real-time infrastructure company) | Onur Solmaz, OpenClaw (open-source agent orchestration) |
| Protocol focus | WebSockets / pub-sub replacing SSE for bidirectional, resumable transport | ACP (Agent Client Protocol) for standardising human-to-agent and agent-to-agent interaction |
What does the Christensen Durable Sessions AI UX Framework do?
Mike Christensen's framework diagnoses a specific failure mode in AI products: the Single-Connection Trap. When your AI chat app streams responses via SSE (Server-Sent Events) — the default in tools like Vercel AI SDK or LangChain streaming — the health of the response is coupled to a single client connection. If the user's network drops, switches tabs, or moves to a phone, the stream is gone. There is no resume, no multi-device sync, and no reliable stop button.
The framework introduces Durable Sessions: a persistent, shared pub/sub channel sitting between your agent layer and your client layer. Agents publish events (tokens, tool results, status updates) to the session. Clients subscribe to it. Neither holds a direct pipe to the other. This single architectural inversion unlocks three foundational capabilities simultaneously: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (the session follows users across tabs and devices), and Live Control (users can steer, interrupt, or cancel mid-generation).
The framework also solves the Orchestrator Dual-Purpose Problem in multi-agent setups — instead of forcing the orchestrator to relay every sub-agent's progress, each sub-agent writes directly to the shared session. Clients see everything with zero additional coordination code.
What does the Solmaz Disposable Agent Orchestration Framework do?
Onur Solmaz's framework addresses a completely different problem: how do you run many autonomous AI coding agents in parallel, at scale, on real infrastructure? If your team faces hundreds of inbound pull requests, bug reports, or issues daily, you cannot have humans in every mechanical loop.
The core abstraction is the On-Demand Disposable Agent — each task gets its own full Kubernetes pod, spun up on demand, torn down when done. The framework uses ACP (Agent Client Protocol) to standardise the human-to-agent interface so one adapter works across Codex, Claude Code, OpenClaw, or any compliant harness. Reusable Standard Operating Procedures (SOPs) encode repeating workflows (e.g., PR review: find intent → judge quality → check CI → shallow refactor loop → escalate if needed) as structured, auditable JSON-output-driven sequences.
A concierge agent on Slack, Teams, or Discord acts as the single front door — receiving human requests and dispatching disposable agent pods behind the scenes. Parallel channel workloads let a single human operator drive 1–5 concurrent agent sessions from a messaging app.
How do Durable Sessions and Disposable Agent Orchestration compare?
These frameworks operate on different layers of the AI product stack and are not direct competitors.
Durable Sessions is a connectivity and delivery-layer framework. It assumes you already have agents producing output and focuses entirely on how that output reaches users reliably, across devices, with live bidirectional control. It is transport-centric.
Disposable Agent Orchestration is a compute and workflow-layer framework. It assumes you already have a way to deliver output to users and focuses on how you provision, run, synchronise, and manage the lifecycle of many agents doing real work. It is orchestration-centric.
Where they overlap is multi-agent architecture. Both frameworks deal with multiple agents producing concurrent output. Durable Sessions solves the visibility problem (how clients see all agent activity through one subscription). Disposable Agent Orchestration solves the execution problem (how agents are provisioned, given tasks, and torn down). A sophisticated system could use both: disposable agent pods running tasks, writing their output to durable sessions that clients subscribe to.
On complexity, Durable Sessions is the lighter lift. It requires a pub/sub layer and a transport swap (SSE to WebSockets). Disposable Agent Orchestration requires a full Kubernetes environment, ACP tooling, state synchronisation across pods, operator setup, and encoded SOP workflows.
Which should you choose?
If you are building or fixing a user-facing AI chat product, start with Durable Sessions. Your users are experiencing dropped streams, no multi-device continuity, and a stop button that does not work reliably. This is the more common pain point and the faster fix. The gap between a fragile demo and a production-quality AI UX is almost entirely in the delivery layer.
If you are running an engineering team drowning in repetitive agent-automatable work — high-volume PR review, bug triage, issue processing — and you have Kubernetes infrastructure, use Disposable Agent Orchestration. This is the right framework when the bottleneck is not delivery but throughput: you need more agents, running in parallel, with structured workflows.
If you are building a platform that does both — runs many agents at scale and delivers their output to users in real time — you likely need concepts from both frameworks. Use Durable Sessions for the user-facing delivery layer and Disposable Agent Orchestration for the backend compute layer.
For most teams today, the user-facing AI UX is the first thing that breaks. Start with Durable Sessions.
// FREQUENTLY ASKED QUESTIONS
Can I use Durable Sessions and Disposable Agent Orchestration together?
Yes, and for complex platforms this is the ideal architecture. Disposable agent pods handle task execution and lifecycle on Kubernetes, while Durable Sessions handle real-time delivery of agent output to users across devices. The agent pods publish to durable session channels; clients subscribe. Each framework addresses a different layer.
Do I need Kubernetes to use the Durable Sessions framework?
No. Durable Sessions is infrastructure-agnostic at the compute layer. It requires a pub/sub system (e.g., Ably, Redis Streams, or similar) and a bidirectional transport like WebSockets, but it does not prescribe where your agents run. You can use serverless, VMs, or containers.
What is the difference between ACP, MCP, and A2A protocols?
ACP (Agent Client Protocol) standardises human-to-agent communication. MCP (Model Context Protocol) gives tools and context to models. A2A (Agent-to-Agent) standardises inter-agent communication. ACP is the focus of Disposable Agent Orchestration — it lets one adapter work across all compliant agent harnesses like Codex or Claude Code.
Why can't SSE support a stop button properly?
SSE is strictly one-way (server to client). The only upstream signal a client can send is closing the connection. But closing is ambiguous — it could mean the network dropped (resume needed) or the user pressed stop (cancel needed). Resume and cancel are mutually exclusive under SSE. Durable Sessions solve this by using a bidirectional transport with explicit cancel signals.
How many concurrent agents can Disposable Agent Orchestration handle?
It scales with your Kubernetes cluster capacity. The framework is designed for high parallelism — one pod per task, with parallel channel workloads letting a single operator drive 1–5 sessions simultaneously. For a 100-person company handling production errors, the concierge pattern dispatches pods on demand with no single-instance bottleneck.
Which framework is better for multi-agent AI products?
It depends on the problem. Durable Sessions is better for multi-agent *visibility* — letting clients see all sub-agent activity through one subscription without orchestrator relay bottlenecks. Disposable Agent Orchestration is better for multi-agent *execution* — provisioning, scheduling, and managing the lifecycle of many concurrent agents.
What is the biggest mistake teams make with AI chat streaming?
Building resume and replay logic inside the agent itself. This couples agent code to connection management, scales poorly across clients and devices, and belongs in a separate session layer. The Durable Sessions framework explicitly moves all delivery complexity out of the agent into a shared persistent channel.
Is the Disposable Agent Orchestration framework only for coding agents?
The examples and tooling focus on coding agents (Codex, Claude Code, OpenClaw), but the underlying patterns — SOPs, concierge dispatch, on-demand pods, ACP standardisation — are applicable to any domain where agents handle high-volume, repeatable tasks. Customer support triage and document processing are natural extensions.