Durable Sessions AI UX vs Self-Improving Trading Agent
// TL;DR
These two frameworks solve completely different problems. Choose the Christensen Durable Sessions Framework if you are building or fixing an AI-powered chat or agent product that suffers from dropped streams, no multi-device support, or lack of user control. Choose the Lewis Jackson Self-Improving Trading Agent Framework if you want to deploy an autonomous crypto/asset trading bot that iterates its own strategy over time. There is zero overlap in use case — your project type dictates the choice instantly.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | Lewis Jackson Self-Improving Trading Agent Framework |
|---|---|---|
| Best For | Engineers building AI chat/agent product experiences that must be resilient, multi-device, and controllable | Traders or hobbyists who want a 24/7 autonomous trading bot that self-improves its strategy |
| Core Problem Solved | Fragile streaming architecture that breaks on disconnect, lacks multi-surface continuity, and offers no live agent control | Static trading bots that never learn from outcomes and require manual strategy tuning |
| Complexity | High — requires rearchitecting your streaming layer, replacing SSE with WebSockets, and introducing a pub/sub session substrate | Moderate — a single oneshot prompt in Claude Code handles most scaffolding; Railway deployment and Hermes setup are guided |
| Time to Apply | Days to weeks depending on existing architecture debt and number of agent surfaces | Hours for initial deployment; weeks to months for meaningful self-improvement cycles to accumulate |
| Prerequisites | Existing AI product with streaming responses, understanding of SSE/WebSocket transports, pub/sub infrastructure access | Claude Code access, Railway.app account, a target asset to trade, defined success/failure metrics, starting capital |
| Output Type | Redesigned streaming architecture with a Durable Sessions layer — infrastructure blueprint and implementation | A live, cloud-hosted trading agent that runs 24/7 and produces weekly self-improvement cycle reports |
| Creator Background | Mike Christensen of Ably (real-time infrastructure platform), presented at AI Engineer conference | Lewis Jackson, AI trading content creator and founder of 01 Systems community |
| Domain Specificity | Domain-agnostic — applies to any AI product with streaming agent responses (SaaS, support, coding assistants, etc.) | Domain-specific — designed exclusively for financial asset trading (crypto, forex, tokens) |
| Self-Improvement Mechanism | None — this is an infrastructure architecture framework, not a learning system | Built-in scientific method loop: one variable change per cycle, scored against defined goals, weekly cadence |
What does the Christensen Durable Sessions AI UX Framework do?
The Christensen Durable Sessions Framework diagnoses and fixes a pervasive problem in AI product architecture: the Single-Connection Trap. Most AI chat products stream responses via SSE (Server-Sent Events) over a direct HTTP connection. When that connection drops — a user switches networks, changes tabs, or moves to a different device — the stream is destroyed. There is no resume, no multi-device visibility, and no way for the user to steer or cancel the agent mid-response without ambiguity.
The framework introduces Durable Sessions, a persistent shared layer between agents and clients built on pub/sub infrastructure. Agents write events to a session channel; clients subscribe to it. This decoupling unlocks three foundational capabilities: Resilient Delivery (streams survive disconnects), Continuity Across Surfaces (sessions follow users across tabs and devices), and Live Control (users can steer, interrupt, or cancel agents in real time via bidirectional transport). It also solves the Orchestrator Dual-Purpose Problem in multi-agent systems by letting every sub-agent write directly to the session, removing the orchestrator's relay burden.
This is a serious infrastructure framework aimed at engineering teams building production AI products. It is not a tool you install — it is an architectural pattern you implement.
What does the Lewis Jackson Self-Improving Trading Agent Framework do?
The Lewis Jackson framework gives you a step-by-step process to deploy an autonomous trading agent that runs 24/7 in the cloud and iteratively improves its own strategy. It is built around the Hermes agent, which reviews trade outcomes on a weekly cadence and applies the scientific method: change one variable, observe the result, promote the winner to the new baseline, repeat.
Setup is driven by a oneshot prompt pasted into Claude Code. The prompt orchestrates environment detection, strategy onboarding (you can bring your own strategy or have one scaffolded), cloud deployment on Railway, and Hermes installation. You define a Well-Defined Goal — specific success and failure thresholds like target monthly return, minimum Sharpe score, and maximum drawdown — and Hermes uses that polarity to orient every improvement cycle.
The first Hermes cycle is read-only: it observes and reports but does not modify the live strategy. You manually approve the transition to live mode. From there, Hermes compounds small, single-variable improvements cycle after cycle. The framework is explicitly designed for crypto and financial asset trading.
How do the Durable Sessions and Self-Improving Trading Agent frameworks compare?
These frameworks operate in entirely different domains and solve unrelated problems. The Durable Sessions framework is infrastructure architecture for AI product teams — it fixes how agent responses reach users. The Self-Improving Trading Agent framework is autonomous strategy execution for traders — it fixes how a trading bot learns from its own results.
The Durable Sessions framework is domain-agnostic: it applies to SaaS AI assistants, coding tools, customer support bots, or any product where an agent streams responses to a client. The Trading Agent framework is domain-locked to financial markets.
Complexity profiles differ sharply. Durable Sessions requires rearchitecting your streaming layer, introducing pub/sub infrastructure, and replacing SSE with WebSockets — a meaningful engineering undertaking. The Trading Agent framework abstracts most setup behind a oneshot prompt and guided phases, making initial deployment accessible to non-engineers, though understanding what the agent is doing with your capital requires financial literacy.
The Trading Agent framework has a built-in learning loop; the Durable Sessions framework does not learn — it provides the infrastructure substrate that other systems (including learning agents) can run on top of.
Which should you choose?
Choose the Christensen Durable Sessions Framework if you are an engineer or engineering team building an AI product where users interact with streaming agent responses and you need those streams to survive disconnects, work across devices, or support real-time user control. If your users lose responses when switching networks, cannot see live activity on a second device, or your stop button is unreliable, this is the framework that fixes it.
Choose the Lewis Jackson Self-Improving Trading Agent Framework if you want to deploy an autonomous trading bot that runs 24/7 and learns from its own trade outcomes. You need a target asset, defined success and failure metrics, starting capital, and a Railway account. This is the right choice if your goal is systematic, self-improving algorithmic trading.
There is no scenario where these two frameworks compete. They address fundamentally different layers of the AI stack. If you are building a trading agent product that also needs resilient streaming to a user dashboard, you might eventually use both — Durable Sessions for the delivery layer, and the Trading Agent framework for the autonomous strategy logic.
// FREQUENTLY ASKED QUESTIONS
Can I use the Durable Sessions framework for a trading bot dashboard?
Yes. If your trading bot streams live updates to a user-facing dashboard, Durable Sessions solves disconnection resilience, multi-device visibility, and real-time control. It handles the delivery layer — it does not handle trading logic. You would pair it with a separate trading strategy system.
Does the Self-Improving Trading Agent work for stocks or only crypto?
The framework is demonstrated with crypto assets but the architecture is asset-agnostic in principle. You define the target asset as an input. However, the oneshot prompt and API integrations shown are oriented toward crypto markets. Adapting to equities or forex may require additional API configuration not covered in the guided setup.
Do I need coding experience to use the Self-Improving Trading Agent framework?
Minimal coding experience is needed for initial setup thanks to the oneshot prompt and Claude Code's guided flow. However, you should understand what the agent is doing with your capital, be able to review Hermes cycle outputs, and know how to read the strategy YAML before approving live mode. Financial literacy matters more than coding skill here.
Is the Durable Sessions framework tied to Ably's product?
The framework describes an architectural pattern — Durable Sessions via pub/sub — that can be implemented with any pub/sub infrastructure. Ably is the creator's platform and a natural fit, but the principles apply to any system providing persistent, resumable, independently addressable channels. You are not locked to a single vendor.
Can the trading agent lose money?
Yes. The Self-Improving Trading Agent is an autonomous system trading real capital. The self-improvement loop reduces risk over time by iterating toward your defined goals, but there is no guarantee of profitability. The first cycle is read-only as a safety measure, and you must define a failure threshold (e.g., max drawdown) to bound losses.
What is the main risk of the Durable Sessions approach?
The main risk is implementation complexity. Rearchitecting from direct HTTP streaming to a pub/sub Durable Sessions layer is a significant engineering investment. Teams must replace SSE with bidirectional transport, introduce a session substrate, and update both agent and client code. The payoff is high but the migration is non-trivial.
Can these two frameworks be used together?
Yes, in a product that combines autonomous trading with a real-time user interface. The Trading Agent framework handles strategy execution and self-improvement; the Durable Sessions framework handles resilient, multi-device delivery of live trading updates to the user's dashboard. They operate at different layers and complement each other.
How long before the trading agent actually improves its strategy?
Hermes runs on a weekly review cadence by default. The first cycle is read-only. Meaningful compounding of improvements typically takes multiple weekly cycles — expect at least 4 to 8 weeks before directional improvement becomes visible. Each cycle changes only one variable, so progress is deliberate but clean.