Kaliski Agent Payments vs Christensen Durable Sessions
// TL;DR
These frameworks solve completely different problems and are complementary, not competitive. Use the Kaliski Safe Agent Payments Framework when you need AI agents to safely spend money with enforceable controls. Use the Christensen Durable Sessions Framework when your AI chat or streaming UX breaks under disconnections, multi-device use, or live agent control. If you're building an agentic product that both transacts and streams responses, you need both.
// HOW DO THEY COMPARE?
| Dimension | Kaliski Safe Agent Payments Framework | Christensen Durable Sessions AI UX Framework |
|---|---|---|
| Best for | Architecting safe payment flows for AI agents — buyer-side controls, seller-side acceptance, and checkout infrastructure | Fixing broken AI chat/streaming UX — resilience to disconnects, multi-device continuity, and live user control of agents |
| Core problem solved | Preventing financial damage when autonomous agents transact on behalf of humans | Preventing lost or broken AI responses caused by fragile single-connection streaming architectures |
| Complexity | High — requires PSP integration (e.g., Stripe), token provisioning, mandate enforcement, and protocol implementation (ACP, 402 flows) | Medium — requires replacing SSE with a pub/sub session layer and bidirectional transport, but no external financial system integration |
| Time to apply | Weeks to months — depends on payment method scope, seller integration, and regulatory requirements | Days to weeks — can be incrementally adopted by inserting a session layer between existing agent and client code |
| Prerequisites | Understanding of payment systems (cards, tokens, PSPs), agent architecture, and credential management | Understanding of streaming protocols (SSE, WebSockets), pub/sub patterns, and client-server architecture |
| Output type | Payment infrastructure design: scoped credentials, checkout protocols, audit trails, and risk analysis interfaces | Streaming architecture design: durable session layer, transport selection, multi-agent event routing |
| Creator background | Steve Kaliski, Stripe — deep payments infrastructure expertise | Mike Christensen, Ably — deep real-time messaging and streaming infrastructure expertise |
| Layer of the stack | Financial transaction layer — credentials, payments, checkout | Delivery and connectivity layer — streaming, sessions, transport |
| Multi-agent relevance | Moderate — focuses on constraining each agent's financial access independently via scoped tokens | High — directly addresses how multiple sub-agents publish progress to a shared session without orchestrator bottlenecks |
| Key architectural principle | Separate non-deterministic discovery from deterministic transaction execution | Decouple agents from clients via a persistent shared session layer |
What does the Kaliski Safe Agent Payments Framework do?
The Kaliski Safe Agent Payments Framework provides a systematic approach to building payment infrastructure that allows AI agents to safely spend money on behalf of humans. It was created by Steve Kaliski of Stripe and addresses a specific, high-stakes problem: when an autonomous agent transacts with a business, how do you prevent it from paying the wrong amount, to the wrong seller, with the wrong credential?
The framework introduces three core constructs. Shared Payment Tokens are scoped credentials that encode mandates — seller limits, amount caps, currency restrictions, and time windows — enforced server-side by the payment service provider. The Machine Payments Protocol uses HTTP 402 responses to let API endpoints signal that payment is required, associating cost directly with the resource being accessed. The Agent-to-Commerce Protocol (ACP) replaces browser-based checkout with structured, programmatic exchanges between agents and sellers.
The foundational principle is Discovery vs. Determinism Isolation: let LLMs explore and recommend non-deterministically, but enforce strict determinism at the credential, payment, and checkout layers. Every design decision minimizes the blast radius — the maximum financial damage if something goes wrong.
What does the Christensen Durable Sessions Framework do?
The Christensen Durable Sessions AI UX Framework diagnoses and fixes the streaming and connectivity failures that make AI chat products feel broken under real-world conditions. Created by Mike Christensen of Ably, it targets the gap between a demo that works on a fast connection and a product that works everywhere.
The framework identifies the Single-Connection Trap — the default architecture where a dropped connection destroys the response stream — and prescribes Durable Sessions as the fix. A Durable Session is a persistent, shared, independently addressable resource 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 unlocks three foundational capabilities: Resilient Delivery (streams survive disconnections and clients resume seamlessly), Continuity Across Surfaces (the session follows users across tabs and devices), and Live Control (users can steer, interrupt, or cancel an agent mid-generation). The framework also solves the Orchestrator Dual-Purpose Problem by letting sub-agents publish directly to the session, eliminating relay bottlenecks.
How do they compare?
These frameworks operate on entirely different layers of the AI product stack and solve fundamentally different problems. The Kaliski framework is about financial safety — making sure agents don't lose money, expose credentials, or transact with the wrong party. The Christensen framework is about delivery reliability — making sure agent responses reach users intact, across devices, with full user control.
There is no overlap in their core concerns. The Kaliski framework never addresses how streaming responses reach the client. The Christensen framework never addresses how payments are authorized or scoped. They share a common architectural instinct — decoupling — but apply it to different seams. Kaliski decouples discovery from transaction execution. Christensen decouples agents from client connections.
In terms of complexity, the Kaliski framework is harder to implement because it requires integration with payment service providers, compliance with financial regulations, and coordination between buyer-side and seller-side systems. The Christensen framework can be adopted more incrementally by inserting a session layer into an existing streaming architecture.
For multi-agent systems, Christensen is more directly relevant: it provides a concrete pattern for how multiple sub-agents publish to a shared session without creating orchestrator bottlenecks. Kaliski addresses multi-agent scenarios through credential scoping — each agent gets its own narrowly scoped token — but does not address the delivery of their outputs.
Which should you choose?
Choose the Kaliski Safe Agent Payments Framework if your AI agents need to spend money — buying products, calling paid APIs, managing subscriptions, or transacting with third-party businesses. This is the right framework for fintech teams, e-commerce platforms enabling agent buyers, and any product where autonomous spend creates financial risk.
Choose the Christensen Durable Sessions Framework if your AI product streams responses to users and you're experiencing broken UX — lost responses on mobile, no multi-device continuity, or an unreliable stop button. This is the right framework for any team building AI chat, coding assistants, research tools, or customer support agents where the model works fine but the delivery layer is fragile.
If you're building a full agentic product that both transacts and streams, you need both. They are complementary layers: Kaliski handles the financial transaction layer, Christensen handles the delivery and connectivity layer. Neither substitutes for the other.
Can these frameworks be used together?
Yes, and for ambitious agentic products, they should be. Consider an AI shopping agent: it uses Durable Sessions to stream its research progress to the user across devices with full stop/steer control (Christensen), and when ready to purchase, it provisions a Shared Payment Token scoped to the selected seller with enforced spend limits (Kaliski). The streaming UX and the payment safety are independent concerns, each addressed by the appropriate framework. The Durable Session ensures the user sees what the agent is doing; the Shared Payment Token ensures the agent can only spend what it's authorized to spend.
// FREQUENTLY ASKED QUESTIONS
Can I use the Kaliski and Christensen frameworks together?
Yes. They solve different problems and are fully complementary. Kaliski handles safe payment execution for AI agents; Christensen handles reliable streaming delivery and UX. A product where agents both transact and stream responses to users benefits from both frameworks applied to their respective layers.
Which framework do I need if my AI agent calls paid APIs?
Use the Kaliski Safe Agent Payments Framework. It defines the Machine Payments Protocol (HTTP 402 flow) specifically for this scenario — the API signals payment is required, the agent reads the cost payload, approves via a scoped credential, and retries. Spend caps limit blast radius if the agent loops unexpectedly.
Why does my AI chat app lose responses when users switch networks?
This is the Single-Connection Trap described by the Christensen framework. Your SSE or direct streaming connection ties response delivery to one connection's health. The fix is introducing a Durable Sessions layer so clients reconnect and resume from exactly where they left off, without any agent-side replay logic.
What is a Shared Payment Token in the Kaliski framework?
A Shared Payment Token is a scoped credential given to a seller instead of a raw card number. It encodes a mandate specifying the permitted seller, maximum spend amount, allowed currency, and expiry window. The payment service provider enforces these constraints server-side, so even a compromised seller cannot exceed the limits.
What is a Durable Session in the Christensen framework?
A Durable Session is a persistent, stateful, shared resource sitting between agents and clients. Agents write events to it; clients subscribe to it. Messages outlive any individual connection. It enables resilient delivery, cross-device continuity, and live agent control — the three capabilities that separate fragile demos from production AI products.
Do I need both frameworks for a simple AI chatbot?
Probably not. If your chatbot only streams text responses and doesn't transact financially, use only the Christensen Durable Sessions framework to ensure reliable delivery. The Kaliski framework becomes relevant only when your agent needs to spend money, manage payment credentials, or complete purchases.
Which framework is harder to implement?
The Kaliski framework is more complex because it requires PSP integration, credential provisioning, mandate enforcement, and potentially seller-side API changes. The Christensen framework can be adopted incrementally by inserting a pub/sub session layer between your existing agent and client code, typically in days to weeks.
How do these frameworks handle multi-agent architectures?
Christensen directly solves multi-agent delivery by letting each sub-agent write to a shared Durable Session, eliminating orchestrator relay bottlenecks. Kaliski handles multi-agent financial access by provisioning separate scoped payment tokens per agent, ensuring each agent can only spend within its own mandate constraints.