Direct HTTP streaming ties an AI response to one client connection, so refreshes, network changes, and other devices can lose visibility or control.
2
A durable session gives agents and clients a persistent shared resource that supports resumability, multi-device access, and live interaction.
3
Pub/sub channels let multiple agents write directly to one session, while clients subscribe once and see the full activity, including human handoffs.
Summary
Mike Christensen argues that many weak AI user experiences come from the connection model around the agent rather than from the model itself. Direct HTTP streaming with SSE is simple, but it ties a response to one client connection. A dropped connection loses the stream, another tab cannot see the work, and SSE cannot distinguish a user pressing stop from an accidental disconnect. Christensen proposes durable sessions, shared persistent resources between clients and agents. Clients subscribe to the session, so they can reconnect, follow activity from another device, and send control messages while an agent works. Multiple agents can write their own updates to the same session instead of routing every detail through an orchestrator. Ably channels provide the pub/sub layer, and Ably AI Transport packages the session behavior into an SDK. The demo shows synchronized tabs, recovery after a forced disconnect, parallel agents, cancellation from another client, and a human support agent joining with the conversation history visible.
Direct HTTP streaming ties the response to one connection
The common implementation sends a request from the client to an agent, then pipes the agent's LLM events back over a persistent server-sent events connection. Christensen says this is easy to build, but it is organized around one client, one connection, and one agent. The stream's health depends on the end client's connection. If that connection drops, the response is gone. A second tab or a phone also has no view of an in-progress response because the stream is a private pipe. Other clients cannot reach the agent to steer, interrupt, or continue its work.
Good AI products need resilient delivery, shared continuity, and live control
Christensen describes three capabilities that separate a fragile demo from a stronger product experience. Resilient delivery lets a client reconnect after Wi-Fi loss, a page refresh, or leaving the app and continue from the point where it stopped. Continuity across surfaces means a session stays synchronized when the user opens another tab or switches to a phone, including live activity. Live control lets the user communicate with an agent while it works, such as sending a follow-up or steering an operation in progress.
Resuming an SSE stream requires application plumbing that the agent must manage
When a client disconnects during a streamed response, the LLM may continue generating events. To resume later, the system must store those events, attach sequence numbers, and add a reconnect handler that identifies and replays the missed events in order. Christensen says the agent then has to manage this separately for every reconnecting client, since each client may have missed a different portion of the stream. A durable session moves event storage and replay out of the agent's responsibility. The agent writes to the session, and clients reconnect to the session and replay what they missed.
SSE is a one-way server-to-client pipe. If a user presses a stop button while an agent is generating, the client has no upstream channel for sending a cancellation. It can only close the connection. The agent then has to decide whether the user cancelled the work or merely disconnected and plans to resume. Continuing means buffering events and spending tokens; cancelling means stopping generation. Christensen cites Vercel's AI SDK documentation, which says a bot is incompatible with resume functionality for this reason. A bidirectional transport such as WebSockets allows clients to send control messages, though it does not solve the multi-device problem by itself.
A durable session gives every client continuous visibility and control
With a durable session, each tab or device maintains a connection to the shared session rather than only connecting when it starts an agent request. That gives every client ongoing visibility into session activity and lets it resume through the same resource. Since the agent also sees activity in the session, any client can send a follow-up, steer the work, or interrupt it. Christensen's example is a flight request started on one device, followed by a change from Tuesday to Wednesday on a phone. The phone can act because it is connected to the shared session.
Agents can write parallel updates directly to the session
In a multi-agent design, an orchestrator may delegate work to specialized agents while the user wants to see their detailed progress. Routing every granular update through the orchestrator gives that component two jobs: coordinating the task and proxying sub-agent activity. Christensen says the orchestrator often only needs the final results. With a durable session, each agent writes independently to the shared resource. Clients subscribe to the session once and see activity from every agent and other clients, while concurrent work remains visible without centralizing every update.
Ably channels provide persistence, addressing, and automatic replay
Christensen describes durable sessions as a pub/sub pattern. In Ably, publishers and subscribers communicate through a named channel rather than directly. A client or agent can address the session by specifying its channel name. Messages outlive an individual connection, device, or agent, and a client that loses its connection can reconnect and receive events from where it left off. Ably AI Transport builds on these channels as a drop-in SDK layer that works with event stream formats across model providers and agent frameworks. It also handles event materialization, multiplexing, multi-client fanout, bidirectional control, push notifications, and shared subscribable data objects.
The demo shows session behavior across tabs, failures, agents, and people
The demonstration uses an electronics-shop support chat. The session stays synchronized across multiple tabs, including client-side and service-side tool activity. Refreshing the page does not lose the streamed response, and forcing a network disconnect lets the client reconnect and continue automatically. A specialized product-research agent writes detailed events directly to the session, and another tab can cancel its work. Two agents then run at the same time on product research and an order cancellation. Finally, a human support agent joins the session and sees the customer's full interaction history before replying as a participant.
"We can even kill the network here. So, we're forcing the client to disconnect and reconnect, and everything just carries on automatically without any additional complexity."16:36
Who should watch
You have an AI chat product that loses an in-progress response when a user refreshes, changes networks, or switches devices.
Your interface needs users to stop, steer, or continue an agent while it is working, and SSE leaves the meaning of a closed connection ambiguous.
You are building a multi-agent workflow or human handoff and want every participant to see the same live session without routing every update through one orchestrator.
