Durable Actors, open source software that gives agents memory
Imagine you hire an assistant with the memory of Dory, the beloved little fish from Finding Nemo. It sounds fun, but the reality is that every time it walks out the door it forgets who you are, what you were working on and where it left the keys. That is exactly what happens today to many artificial intelligence agents, which lose their state as soon as the server restarts or the connection drops. And the fixes for that are a lot like repeating "P. Sherman, 42 Wallaby Way, Sydney" as if there were no tomorrow, except every time we do it the AI bill grows and grows.
It is clear that another solution is needed, and that is where Durable Actors comes in, an open source runtime that Thomas and Olivier, from the Terse team, presented on Hacker News on October 7, 2026, and which reached the front page with dozens of points and eighteen comments, according to the original Show HN thread.
The idea fits in one sentence. A durable actor is a mini server that handles one request at a time and keeps its own SQLite database. There is exactly one per name worldwide, and you call it by that name. That tiny piece with its own state is the perfect primitive for deploying multiplayer agents, where each agent lives in its actor and each user connects to it via websocket, with full horizontal scaling and without hammering a central database.
The project is released under the MIT license and includes a helm chart to make self-hosting easy. Its commercial promise is clear: to work without locking you into a vendor and with built-in observability out of the box. The code lives in the TerseAI repository on GitHub, with a runtime written in Rust and development kits for TypeScript and Python, the two languages supported in this first stage of the project.
What is a Durable Actor and why does it matter?
Think of a cinema ticket clerk with their own booth. They serve one person at a time, keep the money and remember which seats they sold even if the power goes out and comes back. A durable actor works the same way, with methods that run serially so no one steps on anyone else. Data survives interruptions and system restarts, thanks to the use of a SQLite database.
The concept draws on the classic actor model, where each entity is a process that communicates by messages. Cloudflare popularized the modern version in 2021 with its Durable Objects, pieces with SQLite and WebSocket, according to Cloudflare's official documentation. The problem is the toll, because they only run on its network and drag you into its ecosystem.
This is where Durable Actors takes center stage. It offers the same primitive, an addressable process with SQLite placed next to the compute, but with a runtime you start locally with a single command and then self-host on your own infrastructure. For teams building agents that must remember conversations for weeks, that portability changes the rules of technology procurement.
The difference matters for understanding the moment. Agents went from answering questions to executing long tasks with tools, and they need a home to live in between turns. An ephemeral process is no longer enough when the agent manages a CRM or keeps a chat open for months.
How does this runtime work inside?
The flow starts on your laptop. You run the scaffolding, spin up the local server and write your actors in the entry file. One command generates fully typed clients, so backend and frontend share the contract without writing it twice.
Persistence uses a simple annotation on the fields that must survive. You mark a field as persisted and the runtime saves it to SQLite. Methods run serially by default, and an interleaving annotation lets other calls be served while a response is streaming out.
A sample of how Durable Actors work
Configurable compute is the card the authors play with the most pride. With a decorator you declare how much CPU and RAM each class of actor has, along with its data residency. If you want to store a directory of files inside an actor, you assign it four gigabytes and that's it.
Deployment follows two paths. Locally, the same binary accompanies you from laptop to production. On the Terse cloud, you upload your key as a secret and deploy with one command. The helm chart completes the picture for your own Kubernetes cluster.
The star case is the multiplayer agent. Each agent gets its own actor and each user connects to it via websocket. Think of an assistant that several colleagues query at once. Without a stateful coordination point, those scenarios end in data races.
The second use is coordination between agents within a system. Since each actor handles one request at a time, you can protect critical data such as a CRM and let many agents work in parallel without fear of two writes colliding. The actor acts as a guardian with memory, and the agents simply ask it for their turn to read and write in order.
It also shines in classic real-time applications. Chat systems in the style of ChatGPT or Codex, collaboration tools like a simplified Notion and multiplayer rooms fit naturally. The documentation example builds a persistent chat with streaming in a few dozen lines, plus a backend that signs credentials and a frontend that consumes the contract.
It is worth noting that the project is green. The repository was around 120 stars and eight forks in its first week, the documented self-hosting points mainly to Google Cloud, and the promises of unlimited memory and total observability currently come from its authors. Before betting a critical system on it, it is worth reading the runtime code and measuring with your own workloads.
Aspect
Durable Actors
Cloudflare Durable Objects
License
MIT, self-hostable
Closed, Cloudflare network
Languages
TypeScript and Python
Workers with JavaScript and others
Compute
Configurable per actor with decorator
Fixed platform quotas
Persistence
SQLite per actor
SQLite embedded per object
Client
Generated with full types
Platform SDK
Status
New, small community
Mature, five years in production
What sets it apart from its close cousins?
The family of stateful objects has several members. Cloudflare's Durable Objects are the direct reference, with usage-based pricing. Durable Actors presents itself as their portable alternative, with the freedom to run wherever you want and a different API inspired by Swift's actor model.
Another branch is durable execution engines like Temporal or Azure Durable Functions, which manage workflows that resume after failures. Those systems orchestrate execution, while actors manage state with serialized execution. They are cousins that complement each other, and a serious system can use both, one to remember and the other to retry.
Rivet Actors, for its part, pursues a similar goal from another angle, with startup in milliseconds and enormous density per machine. An honest comparison requires independent benchmarks that do not yet exist for the newcomer. After all, every new engine promises speed until someone measures with a stopwatch in hand.
For the everyday developer, the practical question is simpler. If your agent needs to remember a lot for a long time and you want to be able to move clouds, an open runtime with SQLite per actor reduces the risk of lock-in. If you already live inside the Cloudflare ecosystem and it works for you, the original reference remains the conservative option.
The requirements are modern but affordable. You need Node.js version 22.19 or higher along with Bun 1.3.9 or higher, plus Python 3.11 if you are going to use that language's SDK. The scaffolding creates the structure, the local server loads your actors file and the generator spits out the typed client in the directory you choose for your application.
The guided example in the quick start documentation builds a chat app with agents in minutes. You define the actor with its persistent history, generate the client, start the backend that signs the WebSocket grants with a no-store header and open the frontend in the browser. The browser opens the socket against the signed URL and sends its messages in JSON.
An elegant detail is the connection grant. The backend does not open the socket on behalf of the browser; instead it hands it a single-use signed URL that the frontend uses directly. That pass reduces the attack surface and keeps access control in your backend, where it belongs, instead of spreading it across every client.
If something fails, the immediate roadmap promises help. The authors announce for these days the export of SQLite tables via CLI and via MCP, to expose the operational database records to your agent and debug with questions in natural language. Being able to query the actor's internal state with words will be a superpower when it truly arrives.
What this launch says about the future of the backend
The backend for agents is searching for its definitive form, and this launch marks a direction. Far from stateless functions that forget everything when they finish, the sector is moving toward processes with memory that live a long time and sleep at no cost when nobody needs them. Whoever controls that memory will control the next layer of software infrastructure.
We will have to wait and see whether the community adopts this API or whether the closed reference keeps its five-year advantage. The Hacker News launch was promising, with a front page spot and a high-level technical debate. If the helm chart delivers and the MCP export arrives this week, many small teams will finally have a portable home for their agents.