Rivet

Open-source backend infrastructure, honestly reviewed. No marketing fluff, just what you get when you self-host it.

TL;DR

• What it is: Open-source (Apache 2.0) actor-model backend infrastructure — long-running, stateful processes with built-in WebSockets, queues, workflows, and scheduling [README].
• Who it’s for: Developers building AI agents, real-time collaborative apps, or any stateful backend that currently requires gluing together Redis, Postgres, a job queue, and a WebSocket server. Non-technical founders cannot use this without a developer — this is infrastructure, not a product [homepage].
• Cost savings: Replacing a Redis cluster + Postgres + managed job queue + WebSocket server with a single self-hosted Rivet instance saves real money — Cloudflare Durable Objects charges per request and per GB, Redis Cloud starts around $7/month and scales to hundreds, Temporal Cloud bills by action count. Rivet self-hosted: $0 license on a $10–20/month VPS [README][homepage].
• Key strength: Genuinely impressive cold start (~20ms vs ~6s for a Kubernetes pod) and the “scales to zero, $0 idle cost” model that makes AI agent workloads — which are bursty by nature — economical to run [README].
• Key weakness: No independent third-party reviews were found for this tool. All performance benchmarks below come from Rivet’s own README. The managed cloud pricing is not publicly listed. And the target audience is engineers, full stop — if you can’t read TypeScript, this won’t help you [README][homepage].

---

What is Rivet

Rivet describes itself as “the primitive for stateful workloads” [homepage]. What that means concretely: you define an Actor — a long-running TypeScript process — and Rivet handles keeping it alive, persisting its state, waking it when needed, scaling it horizontally, and exposing it over WebSockets or HTTP. The GitHub README opens with: “Rivet Actors are long-running, lightweight processes designed for stateful workloads. State lives in-memory with automatic persistence. Create one per agent, per session, or per user — with built-in workflows, queues, and scheduling.” [README]

The actor model itself isn’t new — Erlang, Akka, Orleans, and Cloudflare Durable Objects all work on variants of the same idea. What Rivet is pitching is an open-source, self-hostable version of Cloudflare Durable Objects that isn’t locked to Cloudflare’s edge network, runs on your own infrastructure, and comes with a full dashboard, observability tooling, and a managed cloud option for when you need global edge deployment without running your own servers [README][homepage].

The project is licensed Apache 2.0 — genuinely permissive, not “fair-code” — so you can self-host, embed it in a commercial product, or distribute it without negotiating a license [README]. As of this review it has 5,261 GitHub stars.

---

Why people choose it

No independent third-party reviews of Rivet were found during research for this article. What follows synthesizes the use cases Rivet’s own documentation and homepage describe, cross-referenced against the known pain points of the infrastructure categories it replaces.

The problem it solves. If you’re building an AI agent that needs to remember conversation history, queue incoming messages while processing, stream tokens back to a client in real time, and occasionally wake up to run a scheduled task — you currently need: Redis (for the queue), Postgres or a vector DB (for the memory), a WebSocket server (for the streaming), and something like Temporal or BullMQ (for scheduling). These are four separate systems to deploy, configure, monitor, and pay for. Rivet consolidates all of that into one Actor [README].

The Cloudflare Durable Objects comparison. Durable Objects is the most direct architectural equivalent. The key complaint about Durable Objects is lock-in: your code runs on Cloudflare’s runtime (not Node.js or Bun), in Cloudflare’s network, billed on Cloudflare’s terms. Rivet runs on Node.js, Bun, or Deno; deploys to Vercel, Railway, Kubernetes, Hetzner, or a bare VM; and the runtime is a library you npm-install [homepage][README]. If Cloudflare bills are growing or you want to run this inside your own VPC for data residency reasons, Rivet is the obvious place to look.

The Temporal/Inngest comparison. Temporal and Inngest handle durable workflows well but don’t natively handle stateful long-lived processes or real-time WebSocket connections — those require adding Redis and a WebSocket layer on top. Rivet’s Actor is the unit that handles both, so you’re not composing two systems [README].

Why developers don’t just use Kubernetes. The README addresses this directly with benchmark numbers: a Rivet Actor cold starts in ~20ms vs ~6 seconds for a Kubernetes pod; memory overhead is ~0.6KB per actor instance vs ~50MB per pod; idle cost is $0 vs ~$85/month for a Kubernetes cluster [README]. These are self-reported figures without third-party replication, but the order-of-magnitude difference is architecturally sound — Rivet’s actors are in-process, not container-per-instance.

---

Features

Based on the README and website:

Core actor runtime:

• In-memory state co-located with compute — zero-latency reads compared to ~1ms for Redis and ~5ms for Postgres [README]
• Automatic persistence to SQLite (newly added) or BYO database [homepage][README]
• Hibernation when idle, wake on incoming request — no idle compute cost [README]
• Horizontal scaling with global edge deployment via Rivet Cloud [homepage]
• Actors run indefinitely; designed for hours-to-weeks-long processes [README]

Communication primitives:

• WebSockets — bidirectional streaming built in [README]
• Queues — durable message queues for async processing [README]
• Broadcast — stream events to all connected clients (used in the AI token streaming example in the README) [README]

Workflow and scheduling:

• Multi-step workflows with automatic retries [README]
• Scheduled tasks — timers and cron jobs within an actor [README]

Storage:

• In-memory state (automatic persistence)
• SQLite per-actor database (recently introduced, highlighted on homepage as new) [homepage]
• External Postgres or FoundationDB (for enterprise clustering) [homepage]

Observability (dashboard included):

• SQLite viewer — browse and query an actor’s database in real time
• Workflow state inspector — progress, steps, retries
• Event monitoring — real-time event stream and state change log
• REPL — call actions and interact with a running actor directly from the dashboard [homepage]

Deployment targets:

• Local development: npm install rivetkit, runs in-process, no servers [homepage]
• Self-hosted: single Rust binary or Docker container [homepage]
• Rivet Cloud: managed global edge, connects to existing cloud (Vercel, Railway, AWS) [homepage]

Framework/runtime support: React, Next.js, Svelte, Hono, Express, Elysia, Node.js, Bun, Deno, Cloudflare Workers [homepage]

---

Pricing: SaaS vs self-hosted math

Rivet self-hosted (Apache 2.0 license):

• Software cost: $0 [README]
• Infrastructure: $10–20/month for a VPS that can handle moderate actor workloads
• FoundationDB is noted as “enterprise” in the docs — unclear if that means paid licensing [homepage]

Rivet Cloud:

• Pricing is not publicly listed on the website as of this review. The homepage links to “Sign Up” and “Talk to an Engineer” with no published tiers [homepage]. Data not available.

What Rivet replaces and what those alternatives cost:

• Cloudflare Durable Objects: $0.15/million requests + $0.20/GB-month storage. At 10M requests/month and 1GB state: ~$1.70/month at low scale, but climbs fast with storage-heavy agents.
• Redis Cloud (managed): Starts ~$7/month for 250MB, scales to $50–100/month for serious workloads.
• Temporal Cloud: Priced per “action” — a 10-step workflow firing 100K times/month can easily run $50–200/month depending on configuration. Pricing not publicly listed; requires contacting sales.
• BullMQ on self-hosted Redis + custom WebSocket layer: Technically free software, but you’re stitching together three systems and operating all of them.

For a solo developer running an AI agent SaaS where each user session is a stateful actor, the self-hosted Rivet path — single Docker container on a $10 Hetzner VPS — consolidates all of the above into one thing. Whether that’s cheaper than Temporal Cloud depends on your workload profile, but it’s almost certainly cheaper than Cloudflare Durable Objects at scale, and it removes the vendor dependency entirely.

---

Deployment reality check

Local development: Install the rivetkit npm package, write an actor, run it. No servers, no infrastructure, actors run in your process. This is the best possible developer experience — you get the exact same API locally that you’ll use in production [homepage].

Self-hosted: Docker container or single Rust binary. Default storage backends are Postgres (bundled in docker-compose) and file system. FoundationDB is the enterprise option for multi-node clustering [homepage][README].

What you actually need for self-hosted:

• A Linux VPS (2–4GB RAM recommended for small workloads)
• Docker (for the containerized path)
• Postgres (bundled in default setup or external)
• A domain and reverse proxy (Caddy or nginx) for HTTPS

What can go sideways:

• The observability dashboard and self-hosted engine are a single Rust binary (rivetdev/engine), which means you’re depending on Rivet’s binary release cadence for security patches and bug fixes — not something you can npm-audit [homepage].
• FoundationDB for clustering is an operationally complex database that very few teams have experience running. If you need multi-node horizontal scaling in self-hosted mode, this is a significant ops investment.
• No independent benchmarks have been published to verify the cold-start and memory claims. The 20ms cold start and 0.6KB memory figures come from Rivet’s own README with methodology notes that reference specific conditions (no actor key, so no cross-region locking, measured with Node.js and FoundationDB) — real-world numbers under production traffic may vary [README].
• Rivet Cloud pricing opacity is a concern. A tool that encourages you to “start local, scale to Rivet Cloud” without publishing what Rivet Cloud costs is asking for a commitment you can’t price upfront.

Realistic time estimate to get a working self-hosted instance: 1–2 hours for a developer comfortable with Docker. The local dev path (just npm install) takes minutes.

---

Pros and cons

Pros

• Apache 2.0 license. No fair-code restrictions, no commercial use limits, no vendor negotiation required. Embed it in your product, resell it, fork it [README].
• Consolidates five systems into one. In-memory state, persistence, WebSockets, queues, and scheduling in a single Actor abstraction. Eliminates the Redis + Postgres + job queue + WebSocket glue that most stateful backends require [README].
• Scales to zero. $0 idle cost for actors that aren’t running is architecturally significant for AI agent workloads, which are bursty — a user session that runs for 30 seconds doesn’t cost you anything while it’s idle [README].
• Local development is frictionless. npm install and write an actor. Same API, no infrastructure to spin up, no Docker required locally [homepage].
• Built-in observability. SQLite viewer, workflow inspector, event monitor, and REPL included in the self-hosted dashboard — not a paid add-on [homepage].
• Framework-agnostic. Works with Next.js, Hono, Express, Bun, Deno — you’re not rewriting your stack [homepage].
• SQLite per-actor. The recently added per-actor SQLite database is well-suited for the “one database per tenant” pattern that’s expensive to implement with traditional shared-database architectures [homepage].

Cons

• Developer tool only. If you don’t write TypeScript, you can’t use this. There is no UI, no workflow builder, no no-code interface. Non-technical founders are not the audience, regardless of what unsubbed.co’s typical readership looks for [homepage][README].
• No publicly listed cloud pricing. “Talk to an Engineer” for cloud pricing is a red flag for a developer tool — it means pricing scales with your leverage, not a published rate card [homepage].
• Self-reported benchmarks only. The headline performance numbers (20ms cold start, 0.6KB memory, 0ms read latency) come from Rivet’s own README with no third-party replication. Worth testing in your environment before committing [README].
• FoundationDB dependency for clustering. Horizontal scaling in self-hosted mode requires FoundationDB, which has a steep operational learning curve. Most teams don’t have FoundationDB expertise [homepage].
• 5,261 GitHub stars is modest for infrastructure. Temporal has 12K+, n8n has 100K+, Cloudflare Durable Objects is platform-bundled. Rivet is a smaller project, which means smaller community, fewer battle-tested production deployments, less ecosystem tooling.
• No third-party reviews found. For a tool you’re putting in the critical path of your application, the absence of independent reviews means you’re relying entirely on the vendor’s own claims.
• Actor model has a learning curve. If your team thinks in request/response, shifting to long-lived stateful actors requires a mental model change that isn’t trivial.

---

Who should use this / who shouldn’t

Use Rivet if:

• You’re a developer (or have one) building AI agents where each agent needs persistent memory, message queuing, and real-time streaming — and you’re tired of stitching Redis + Postgres + a WebSocket server together.
• You’re currently paying for Cloudflare Durable Objects and want to remove the vendor lock-in without rebuilding your actor logic.
• You’re building a multi-tenant SaaS where each tenant should have isolated state (per-tenant DB pattern) and you want that isolation at the infrastructure level rather than the query level.
• You want Apache 2.0 licensing so you can embed this in a product you sell.

Skip it if:

• You’re a non-technical founder. There is no version of this you can operate without writing TypeScript.
• You need a proven production track record with public case studies — none were found.
• Your workload is simple CRUD with no real-time or long-lived session requirements. A Postgres-backed REST API doesn’t need actors.
• Cloud pricing transparency matters to you before you build on a platform.

Consider alternatives if:

• Your team is already invested in Kubernetes and the 6-second cold start is acceptable — Rivet’s operational complexity may not be worth the gains.
• You need workflow orchestration primarily (not stateful real-time) — Temporal or Inngest are better-tested in that specific slot.

---

Alternatives worth considering

• Cloudflare Durable Objects — The closest architectural equivalent. Globally distributed, production-proven, integrated with Cloudflare’s edge. Locked to Cloudflare’s runtime and pricing. Choose this if Cloudflare lock-in doesn’t bother you and you want a battle-tested managed service.
• Temporal — Purpose-built for durable workflow orchestration. More mature, larger community, better documentation. Doesn’t handle real-time WebSocket connections natively. Choose Temporal if your problem is primarily workflow coordination rather than stateful long-lived sessions.
• Inngest — Serverless durable functions with a good developer experience. Hosted-first. Choose Inngest if you want the simplest path to durable functions without self-hosting anything.
• Partykit — Similar actor model specifically for real-time collaborative apps (documents, games, chat). More opinionated, narrower scope. Choose Partykit if your use case is collaboration over general stateful workloads.
• Modal — Serverless Python-first compute with persistent state options. Better for ML/data workloads than TypeScript backends.
• Fly.io Machines — Long-running VMs that scale to zero, with fast restarts. Less integrated than Rivet but more flexible for non-JavaScript runtimes.

---

Bottom line

Rivet is solving a real problem: stateful backends for AI agents currently require assembling five separate systems, and Cloudflare Durable Objects solves this cleanly but locks you into one vendor. Rivet’s actor model is architecturally sound, the Apache 2.0 license is genuinely permissive, and the local development experience (npm install, actors run in-process) is the right design. The self-reported performance numbers are impressive if they hold in production.

What’s missing: independent reviews, public cloud pricing, and the kind of community evidence that comes from a tool being in production at scale for years. At 5,261 GitHub stars, Rivet is early. That’s not disqualifying — every mature infrastructure project was once early — but it means you’re accepting more technology risk than you would with Temporal or Cloudflare Durable Objects.

For a developer building an AI agent SaaS who wants to self-host, avoid vendor lock-in, and stop gluing systems together: Rivet is worth a serious evaluation. For anyone who isn’t writing TypeScript: this isn’t the tool.

If you want someone to deploy and maintain this for your team without dealing with the infrastructure yourself, that’s what upready.dev handles.

---

Sources

Note: Third-party review articles provided for this research were unrelated to Rivet (rivet.dev). The review above is based entirely on primary sources.

1. Rivet GitHub README — rivet-dev/rivet repository, Apache-2.0 license. https://github.com/rivet-dev/rivet
2. Rivet official website and homepage — product description, benchmarks, feature list, infrastructure diagram. https://rivet.dev
3. Rivet self-hosting documentation — Docker and binary deployment instructions. https://rivet.dev/docs