Durable Sessions vs Autonomous Payments: Which Do You Need?
// TL;DR
These two frameworks solve completely different problems and are not substitutes. If your AI product streams responses to users and breaks on disconnects, multi-device use, or lacks a stop button, use the Christensen Durable Sessions Framework. If your AI agents need to spend money—buying API calls, goods, or services on behalf of users—use the Kaliski Autonomous Payment Infrastructure Framework. Many production AI products will eventually need both: Durable Sessions for reliable real-time UX, and Autonomous Payments for safe agent commerce.
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | Kaliski Autonomous Payment Infrastructure Framework |
|---|---|---|
| Best for | Fixing broken AI chat/streaming UX — disconnects, multi-device sync, stop buttons | Enabling AI agents to safely spend money at third-party merchants and APIs |
| Core problem solved | Stream fragility and single-connection coupling between agent and client | Credential risk, overspend, and non-deterministic payment execution by agents |
| Complexity | Medium — requires replacing SSE with pub/sub session layer and bidirectional transport | Medium-High — requires implementing new protocols (ACP, 402 flow), token provisioning, and seller-side API surfaces |
| Time to apply | Days to weeks for audit and architectural refactor of streaming layer | Weeks to months depending on payment processor integration and seller adoption |
| Prerequisites | An existing AI product with streaming responses (SSE, WebSockets, or polling) | An AI agent workflow that needs to make purchases or pay for API access |
| Output type | Redesigned streaming architecture with persistent session layer between agents and clients | Secure payment flow with scoped tokens, structured checkout APIs, and audit trails |
| Creator background | Mike Christensen, Ably — real-time infrastructure and pub/sub messaging specialist | Steve Kaliski, Stripe — payment infrastructure and fintech specialist |
| Protocol layer affected | Transport and session layer (WebSockets, pub/sub channels) | Application and payment layer (HTTP 402, ACP checkout APIs, tokenized credentials) |
| Multi-agent support | Strong — sub-agents write directly to shared session, eliminating orchestrator relay bottleneck | Indirect — each agent gets its own scoped payment token; no shared payment session concept |
| Human-in-the-loop pattern | Human agent can join an existing Durable Session with full context for handoff | Human operator confirms structured cart state before final payment execution |
What does the Christensen Durable Sessions AI UX Framework do?
The Christensen Durable Sessions Framework diagnoses and fixes a pervasive problem in AI products: the streaming connection between your AI agent and the user's client is fragile. When you use SSE (Server-Sent Events) via tools like the Vercel AI SDK or LangChain streaming, a single dropped connection destroys the response. Users on mobile lose their answer when they switch networks. A second browser tab or device cannot see the live response. And the stop button is broken because closing an SSE connection is ambiguous—it could mean "I disconnected" or "I pressed stop."
The framework introduces Durable Sessions: a persistent, shared session layer that sits between agents and clients. Agents write events 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 (sessions follow users across tabs and devices), and Live Control (clients can steer, interrupt, or cancel agents mid-generation). The natural implementation substrate is a pub/sub channel model with sequence-numbered, resumable messages.
For multi-agent architectures, Durable Sessions eliminate the orchestrator relay bottleneck. Instead of forcing the orchestrator to proxy progress updates from five sub-agents back to the client, each sub-agent writes directly to the shared session. The client subscribes once and sees everything.
What does the Kaliski Autonomous Payment Infrastructure Framework do?
The Kaliski Framework solves a fundamentally different problem: how do AI agents safely spend money? Agents are already economic actors—every LLM call converts tokens to dollars. The challenge is extending that spending to arbitrary third-party merchants without creating massive credential risk, overspend exposure, or fraud surface area.
The core principle is Discovery vs. Determinism Separation: LLMs are great for finding products and making recommendations (non-deterministic), but payments and checkout must be purely deterministic. Never let browsing behaviour touch the transactional layer.
The framework introduces three key mechanisms. First, Shared Payment Tokens—credentials that wrap an underlying payment method and encode a mandate (spend cap, currency, time window, target seller) enforced by the payment processor, not the seller. Second, the Machine Payments Protocol (HTTP 402 flow)—when an agent hits a paid API endpoint, the server returns 402 with payment instructions; the agent resolves payment and retries. Third, the Agent-to-Commerce Protocol (ACP)—a structured, stateful API-driven checkout loop co-developed with OpenAI, replacing browser-based form-filling with deterministic JSON exchanges for catalog browsing, cart management, and payment submission.
Sellers remain in control. The framework does not hide the agent from the seller; it gives sellers structured data (card brand, last four digits, credit type) for their existing risk systems.
How do they compare?
These frameworks operate on entirely different layers of the AI product stack and address unrelated failure modes.
Durable Sessions is an infrastructure-layer framework focused on the transport between AI agents and human users. It assumes your agents already produce useful output and fixes how that output reaches the user reliably across connections, devices, and interaction patterns.
Autonomous Payment Infrastructure is an application-layer framework focused on the transaction between AI agents and third-party merchants or APIs. It assumes your agent already knows what to buy and fixes how it pays safely without exposing raw credentials or producing non-deterministic checkout behaviour.
The two frameworks share a design philosophy—both insist on decoupling concerns that naive architectures conflate. Durable Sessions decouples agent logic from connection management. Autonomous Payments decouples discovery logic from transactional execution. But they solve problems that never overlap: one is about delivering streaming tokens to a screen; the other is about delivering dollars to a seller.
A key distinction is in the human-in-the-loop pattern. Durable Sessions enable a human support agent to join an ongoing AI conversation with full context. Autonomous Payments enable a human operator to approve a structured purchase before money moves. Both are critical safety mechanisms, but they serve different product moments.
Which should you choose?
Choose Durable Sessions if you are building or maintaining an AI chat, copilot, or agent-driven interface where users interact with streaming responses. If users lose responses on mobile, cannot see live generation on a second device, or your stop button is unreliable, this framework directly fixes those problems. It is the right starting point for any team whose AI product works in demos but breaks in production.
Choose Autonomous Payment Infrastructure if your AI agents need to purchase things—API calls, cloud credits, e-commerce products, or SaaS subscriptions—on behalf of a user. If you are building an AI shopping agent, an autonomous procurement workflow, or a tool-using agent that hits paid endpoints, this framework defines how to do it without creating a financial liability.
Choose both if you are building a full-stack agentic product where agents both interact with users in real time and transact with external services. The frameworks are complementary, not competitive. Apply Durable Sessions to your user-facing streaming layer. Apply Autonomous Payments to your agent-to-merchant transaction layer. There is no architectural conflict between them.
If you must prioritize, start with whichever addresses your current pain point. Most teams hit streaming UX problems first (Durable Sessions) because they affect every user session. Payment infrastructure becomes critical when agents begin transacting autonomously, which is a later-stage capability for most products.
// FREQUENTLY ASKED QUESTIONS
Can I use Durable Sessions and the Kaliski payment framework together?
Yes, and many mature AI products should. Durable Sessions handle the real-time streaming layer between agents and users—resilient delivery, multi-device sync, live control. The Kaliski framework handles the payment layer between agents and merchants. They operate on different layers of the stack with no architectural conflict. Apply Durable Sessions to your UX transport; apply Autonomous Payments to your agent commerce flows.
Do I need Durable Sessions if I'm already using WebSockets?
Likely yes. WebSockets give you bidirectional transport, which solves the SSE Resume-Cancel Conflict for live control. But WebSockets alone do not provide session persistence, multi-device visibility, or automatic resumability. If a WebSocket connection drops, you still lose the stream unless you have a Durable Sessions layer that buffers and replays missed events. Bidirectionality is necessary but not sufficient.
What is a Shared Payment Token and how is it different from a credit card?
A Shared Payment Token wraps an underlying payment method (like a credit card) and adds an enforceable mandate—a maximum spend amount, permitted currency, time window, and target seller scope. The payment processor enforces these limits, not the seller. This means even if the token is compromised or misrouted, the blast radius is tightly contained. A raw credit card number has no such built-in limits.
Why can't I just use SSE with reconnection logic for resilient AI streaming?
SSE reconnection helps with basic drops, but it creates two fundamental problems. First, resume logic built into the agent couples your agent code to connection management, adding complexity that scales poorly. Second, SSE is one-way—closing the connection is ambiguous between a user cancel and a network disconnect, making resume and cancel mutually exclusive. Durable Sessions solve both by externalizing replay to a session layer and requiring bidirectional transport for control signals.
What is the Agent-to-Commerce Protocol (ACP)?
ACP is a standard set of APIs co-developed by Stripe and OpenAI that defines a stateful, structured checkout loop between an AI agent and a seller. Instead of the agent scraping a website or filling out HTML forms, ACP exposes a JSON product catalog and a deterministic back-and-forth for cart creation, quantity updates, shipping selection, and payment. Each step returns the full cart state in structured form so the agent never infers prices from a UI.
Which framework should I implement first for a new AI product?
Start with Durable Sessions. Streaming UX problems—dropped responses, no multi-device sync, broken stop buttons—affect every user session from day one. Payment infrastructure becomes critical later, when your agents begin autonomously transacting with external services. Most teams hit UX reliability issues months before they need agent commerce capabilities.
Does the Kaliski framework work with cryptocurrency payments?
Yes. The framework is payment-method agnostic. Shared Payment Tokens can wrap cards, wallets, or on-chain payment methods. The Machine Payments Protocol (402 flow) supports encoded payment instructions that can specify crypto as the mechanism. The core principles—mandates, scoped credentials, deterministic execution—apply regardless of whether the underlying settlement is fiat or crypto.
How do these frameworks handle multi-agent architectures?
Durable Sessions handles multi-agent scenarios directly: every sub-agent writes progress updates to a shared session channel, eliminating the orchestrator relay bottleneck. The client subscribes once and sees all agent activity. The Kaliski framework handles multi-agent spend by issuing each agent its own tightly scoped Shared Payment Token. There is no shared payment session—each agent transacts independently within its mandate.