Systems | Development | Analytics | API | Testing

Raw WebSockets drop connections, lose track of canceled responses, and don't natively reach a second device. If your AI streaming feature has been in production for a while, you've probably already built a fix for at least one of these and found another one waiting. Reconnection, cancellation, multi-device delivery, and crash detection are the four problems raw WebSockets leave for you to solve, and each is its own piece of infrastructure to build. Solve one, and the other three remain unsolved.

If you build an agent against OpenAI's Responses API then the simplest way to get output to the user is streaming over HTTP/SSE. If the user refreshes the page, loses connection, switches devices, or needs to approve a tool call, then there's nothing in the API to help you. AI Transport is Ably's session layer for agent-to-user conversations. An agent built on it gets resumable streams, multi-device sessions, and approval gates that wait for a human user, without deploying additional infrastructure.

Until now, sending push notifications to a React Native app with Ably meant registering devices manually through the push admin API, usually from a server. The new plugin moves activation where it belongs: onto the device. We've added first class support for React Native apps receiving push notifications through the Ably PubSub JavaScript SDK.

If you're running a customer-facing AI agent on Temporal, you've probably seen this: a user refreshes the tab mid-response. When the page comes back, the response resumes, but anything they were about to send back (an interruption, a tool approval) is gone. Temporal keeps the workflow itself crash-proof, but getting its output to a browser, and taking anything back from the browser into the workflow, has always meant building it yourself.

Steering lets a client redirect an agent while the agent is still working, so a follow-up message reshapes the answer in flight instead of cancelling the Run and starting over, or waiting for it to finish. In the AI Transport SDK, a Run encapsulates the agent's output for a single turn (including multiple iterations around an agentic loop). The last release, v0.5.0, made a single agent turn survive a crash by splitting a Run into re-attemptable Steps.

Until recently, we extensively used HashiCorp's CDK for Terraform. Then they announced the end of its development. We didn't want to spend months migrating to a new ecosystem, but we needed a replacement. In the Infrastructure Team at Ably, we like Go. I wondered if there was an opportunity for something simpler.

Shared state is a hard problem in the unglamorous sense: the concepts are well understood, but someone still has to build the conflict resolution, the reconnection handling, and the state recovery before anyone can ship the feature that depends on it. That's what LiveObjects is for, and the path-based model that reshaped the API in JavaScript is now available to Java developers too.

A dropped connection used to cost a typing indicator. With AI in the product, it costs an entire response, mid-generation. That single shift is enough to reopen a decision most teams made years ago and stopped thinking about: whether to keep building realtime infrastructure themselves, or buy it. Fin, the AI agent platform formerly known as Intercom, made the call to buy. It had run its own realtime system, Nexus, for years, at the scale of one of the biggest support platforms on the internet.

AI Transport v0.5.0 is now available. It adds first-class support for running an agent turn inside a durable execution framework, such as Temporal or Vercel's Workflow Development Kit (WDK), while every client watching the conversation still sees one clean, resumable stream. The last release, v0.4.0, let an agent hydrate its history from your own database. This one is about what happens when the process running the agent isn't around for the whole turn.

HTTP works fine for a chatbot that responds in seconds. Add token streaming, and it mostly still works. But once an agent starts doing things that take real time, reasoning across multiple tool calls, spawning sub-agents, running for minutes instead of milliseconds, the UX starts to falter. The connection drops while the agent is mid-thought. The user switches tabs, comes back five minutes later, and the session is gone. The agent finishes its work, but the client has already moved on.