+ Start in 5 minutes. Deploy anywhere. Scale to millions. +
+ +Like Lambda, but with memory. No 5-minute timeouts. No state loss.
++ State lives with your compute. Reads and writes are in-memory. No database round-trips. +
++ WebSockets and SSE out-of-the-box. Broadcast updates with one line of code. +
++ Actors automatically hibernate to save costs and wake up instantly (zero cold start) on demand. +
++ No vendor lock-in, ever. Run on Rivet Cloud, Vercel, Railway, or your own bare metal. +
++ Built-in failover and automatic restarts preserve state integrity. +
+
+ {"{"}
+ "count"
+ :
+ {JSON.stringify(actorState.count)}
+ {"}"}
+
+ + Stop faking state with databases and message queues. Rivet is the open-source library for long-lived compute—we call them Actors. It's what you reach for when Lambda runs out of road. +
+ +{useCase.description}
+{useCase.description}
+Your serverless function spins up.
+It queries a database.
+It does its job and dies.
++ The pain: Latency. Complexity. Cost. +
+So you add Redis for state. And a message queue for jobs. And a WebSocket server for realtime.
+Your app is now a complex, distributed monolith.
+Your logic and state live together. One library. One process. It's fast, resilient, and scales from zero.
+No database round-trips. No queues. Just code.
++ The gain: Simplicity. Speed. Power. +
++ Works Where You Work +
+
+
+ // Define your actor
+ {"\n"}
+ export const aiAgent ={" "}
+ actor({"{"}
+ {"\n"}
+
+ {" "}
+ // Persistent state that survives restarts
+ {"\n"}
+ {" "}
+ state: {"{"}
+ {"\n"}
+ {" "}messages: [] as Message[],
+ {"\n"}
+ {" "}{"},"}
+
+ {"\n"}
+
+ {" "}actions: {"{"}
+ {"\n"}
+ {" "}
+ // Call functions from clients
+ {"\n"}
+ {" "}sendMessage: async (c, userMessage:{" "}
+ string) ={">"} {"{"}
+
+ {"\n"}
+ {" "}
+ const userMsg = {"{"} role:{" "}
+ "user", content: userMessage {"}"};
+ {"\n"}
+ {" "}
+ {"\n"}
+
+ {" "}
+ // State changes are automatically persisted
+ {"\n"}
+ {" "}
+ c.state.messages.push(userMsg);
+ {"\n"}
+ {" "}
+ const assistantMsg ={" "}
+ await{" "}
+ getAIReply(
+ c.state.messages);
+ {"\n"}
+ {" "}
+ c.state.messages.push(assistantMsg);
+
+ {"\n"}
+
+ {" "}
+ // Send events to all connected clients
+ {"\n"}
+ {" "}c.broadcast(
+ "messageReceived", assistantMsg);
+ {"\n"}
+ {" "}
+ return assistantMsg;
+
+ {"\n"}
+ {" "}{"},"}
+ {"\n"}
+ {" "}{"},"}
+ {"\n"}
+ {"}"});
+
+
+ + Declare your state in a simple object. Rivet handles persistence, replication, and storage for you. + It's just there. +
++ Write functions that clients can call. These are your entrypoints, just like a serverless function or + API route. +
+
+ Just modify{" "}
+ c.state. Reads
+ and writes are instant. No database round-trips, no `await`.
+
+ Use{" "}
+ c.broadcast to
+ send events. No external pub/sub or WebSocket server needed. It's built-in.
+