Rivet

Actor-model infrastructure for stateful workloads, honestly reviewed. Built for developers who want Durable Objects without the vendor lock-in.

TL;DR

• What it is: Open-source (Apache-2.0) actor-model infrastructure platform — long-running, stateful processes with in-memory state, WebSockets, queues, and scheduling baked in [README][homepage].
• Who it’s for: Developers and technical founders building AI agents, real-time collaborative apps, or durable workflows who want to escape Cloudflare lock-in or avoid paying for managed orchestration platforms like Temporal Cloud [README][homepage].
• Cost savings: Cloudflare Durable Objects charges $0.15/million requests plus $0.20/GB-month for storage. Self-hosting Rivet on a $10–20/mo VPS gives you the same actor primitives with a fixed bill regardless of request volume [homepage].
• Key strength: 20ms cold starts, ~0.6KB memory overhead per actor, true zero idle cost, and a global edge deployment story — with a single Rust binary self-hosted option that actually works [README][homepage].
• Key weakness: This is developer infrastructure, not a no-code tool. Non-technical founders cannot use this without an engineer. Pricing for Rivet Cloud is not publicly listed. The project has 5,261 GitHub stars — solid traction but nowhere near the scale of Temporal or Cloudflare’s ecosystem [merged profile].

---

What is Rivet

Rivet is a backend infrastructure platform built around the “Actor” model. An Actor is a long-running, lightweight process that holds in-memory state, persists to SQLite or a database of your choice, accepts messages via queues, streams events over WebSockets, and runs scheduled tasks — all in one unit [README].

The pitch is simple: instead of assembling a state store (Redis), a message queue (SQS/BullMQ), a WebSocket server, a workflow engine (Temporal), and a scheduler (cron + something), you create one Actor. Each AI agent gets an Actor. Each user session gets an Actor. Each collaborative document gets an Actor. State, storage, networking, and queuing are primitives of the Actor itself, not services you wire together [README][homepage].

What makes this notable for self-hosters is the Apache-2.0 license and the self-hosting story. The README describes two paths: install RivetKit as a plain npm library and run actors locally in your process during development, or deploy a single Rust binary (or Docker container) for production that brings a full dashboard and works with Postgres, file system, or FoundationDB for persistence [homepage]. There is no “community edition vs. enterprise edition” split on the self-hosted path — the Apache-2.0 license means you can run the full thing without calling a lawyer [homepage].

The project sits at 5,261 GitHub stars and is actively maintained with a Discord community and regular changelog updates [merged profile][homepage].

---

Why developers choose it

The most direct comparison is Cloudflare Durable Objects. Durable Objects give you persistent, stateful actors at the edge — but they only run inside Cloudflare Workers. Your code must target the Workers runtime. Your state lives in Cloudflare. Your traffic goes through Cloudflare. Rivet makes the same architectural bet (actors as the primitive for stateful workloads) but runs on infrastructure you control: your VPS, your Kubernetes cluster, your cloud account [README][homepage].

The benchmarks in the README put this into concrete terms. Rivet Actor cold starts measure around 20ms versus ~6s for a Kubernetes pod and ~30s for a VM. Memory overhead runs ~0.6KB per actor instance versus ~50MB for a Kubernetes pod and ~512MB for a VM. Idle cost is $0 (actors hibernate when not in use) versus ~$5/mo for a VM and ~$85/mo for a Kubernetes cluster just to keep it running [README]. These aren’t comparisons against Cloudflare Durable Objects directly — that’s intentional, since comparing managed edge latency against self-hosted is apples to oranges — but the numbers explain why someone building an app with thousands of concurrent agents would care about per-instance overhead [README].

The AI agent use case is where Rivet’s pitch is sharpest. The README’s canonical example is an agent actor: it holds conversation history in in-memory state (no round-trip to Redis), processes messages from a durable queue, streams tokens back to the client over WebSockets, and persists the full conversation to SQLite between sessions [README]. You can create one actor per user, per session, or per agent run — the system scales to match. If your agent is idle, it costs nothing [README][homepage].

For collaborative apps (think shared documents, multiplayer state, per-room chat), the actor-per-document or actor-per-room pattern maps directly: each actor holds its document state in memory, broadcasts changes to all connected WebSocket clients, and persists diffs to SQLite. No Redis pub/sub, no separate presence layer [README].

The workflow use case competes with Temporal, Inngest, and similar durable execution platforms. Rivet includes multi-step workflows with automatic retries, scheduling (timers and cron), and durable queues inside the Actor primitive — not as a separate service you deploy alongside your app [README][homepage].

Note: no usable third-party reviews of Rivet were available during research. The analysis above draws on the official README and website.

---

Features

Core Actor primitives:

• In-memory state co-located with compute — reads at 0ms latency, no round-trip to an external store [README]
• Automatic persistence to SQLite (built-in) or BYO database [README][homepage]
• Actors run indefinitely when active, hibernate when idle [README]
• Scales to zero cost when idle, scales infinitely under load [README]
• Global edge network deployment for geographic distribution [homepage]

Communication and coordination:

• WebSockets for real-time bidirectional streaming [README]
• Durable message queues for reliable async processing [README]
• Broadcasting to all connected clients from within an actor [README]
• Multi-step workflows with automatic retries [README]
• Scheduling: timers and cron jobs inside an actor [README]

Developer experience:

• RivetKit npm library — actors run in-process during local development, no infrastructure required [homepage]
• TypeScript/JavaScript SDK with typed actor definitions [README]
• Full observability dashboard: SQLite viewer, workflow state inspector, event monitoring, REPL for live actor debugging [homepage]
• Works with Node.js, Bun, Deno, Cloudflare Workers runtimes [homepage]
• Integrates with React, Next.js, Svelte, Hono, Express, and tRPC on the client side [homepage]
• OpenAPI and AsyncAPI support [homepage]

Infrastructure:

• Single Rust binary or Docker container for self-hosting [homepage]
• Postgres, file system, or FoundationDB (enterprise) for persistence backends [homepage]
• Docker and Kubernetes deployment supported [merged profile]
• REST API, WebSocket, scheduled tasks, PostgreSQL, Redis, SQLite in the feature set [merged profile]
• Rivet Cloud managed option with global edge network and automatic scaling [homepage]

---

Pricing: SaaS vs self-hosted math

Rivet Cloud: Pricing is not publicly listed on the website. The site directs you to “Sign Up” without showing a pricing page in the scraped data. You’d need to contact the team or create an account to see current rates. Data not available for a direct comparison.

Self-hosted:

• License: $0 (Apache-2.0) [homepage]
• Single Rust binary or Docker container on a VPS
• A Hetzner CX21 (2 vCPU, 4GB RAM) runs ~$5–7/mo and comfortably handles hundreds of concurrent actors for a small application
• FoundationDB backend for enterprise-grade durability requires additional setup

Cloudflare Durable Objects for comparison:

• $0.15 per million requests
• $0.20 per GB-month for storage
• Free tier: 1 million requests/day, 1GB storage
• At 10 million requests/month with 5GB storage: ~$2.50/mo — cheap at low scale, grows linearly

Temporal Cloud for comparison:

• Priced per action (workflow task, activity, signal, etc.)
• Roughly $25–50/month for a small application, $200–500+/month for production-grade workloads
• Temporal self-hosted is free but operationally complex (requires its own Postgres/MySQL, Elasticsearch for visibility, separate worker processes)

The math that matters: If you’re running significant actor workloads on Cloudflare Durable Objects or paying for Temporal Cloud, self-hosted Rivet converts a usage-based bill to a fixed infrastructure cost. The break-even point depends on your request volume, but for anything with consistent traffic (rather than spiky serverless bursts), a fixed $10–20/mo VPS almost always wins over per-request pricing [homepage][README].

The caveat: Cloudflare’s edge is genuinely global with sub-10ms cold starts anywhere on the planet. Self-hosted Rivet is as fast as your deployment region. If your users are globally distributed, Rivet Cloud’s edge network is the right answer — but you’re back to depending on pricing that isn’t public.

---

Deployment reality check

The straightforward path:

docker run -p 6420:6420 rivetdev/engine

That is the self-hosted install command from the homepage. Single Docker container, port 6420, full dashboard included [homepage]. For local development, you don’t even need Docker — install the npm package and actors run in your existing Node.js process [homepage].

What you actually need for production:

• A Linux VPS or Kubernetes cluster
• Docker or Rust build environment
• Postgres (for durable state persistence at scale) or file system (for simpler deployments)
• A domain and reverse proxy (Nginx or Caddy) for HTTPS
• FoundationDB if you want enterprise-grade distributed storage (not required for most use cases)

What the dashboard gives you:

• SQLite viewer for browsing actor state in real time
• Workflow state inspector showing step progress and retry counts
• Event monitor for all actor events
• REPL to call actor actions and subscribe to events live [homepage]

This observability story is genuinely better than Temporal’s default setup, which requires separate Elasticsearch infrastructure to get workflow visibility. Rivet packages it in the same binary [homepage].

What can go sideways:

• The FoundationDB backend for enterprise persistence is listed as an option but documentation depth for it isn’t clear from the public site. If you need multi-region durability, verify the operational complexity before committing.
• Rivet Cloud pricing opacity means you can’t budget for scale before you build. For founders making infrastructure decisions, unknown pricing at scale is a real risk.
• 5,261 GitHub stars is healthy for a newer project, but the community is smaller than Temporal’s or Cloudflare’s ecosystem. If you run into edge cases, you’re more likely to be debugging solo.
• The global edge network story on self-hosted means “pick your region.” True geographic distribution requires Rivet Cloud or you build multi-region yourself.

Realistic setup time: 20–30 minutes from zero to a working local actor using RivetKit. 1–2 hours for a production Docker deployment with Postgres on a fresh VPS. This is genuinely easy compared to self-hosting Temporal.

---

Pros and cons

Pros

• Apache-2.0 license. Genuinely open, commercially usable, no “fair-code” restrictions or enterprise licensing gates. You can embed it in a product you sell [homepage].
• Single-binary self-hosting. One Docker container gets you the full engine, dashboard, and persistence. Self-hosting Temporal requires 4–6 separate components. Rivet is not that [homepage].
• Best-in-class observability out of the box. SQLite viewer, workflow inspector, REPL, and event monitor included in the self-hosted binary — not sold separately [homepage].
• Zero idle cost architecture. Actors hibernate when inactive. You don’t pay (or provision) for capacity that’s sitting idle [README].
• Local-first development. RivetKit is a library. Actors run in your local Node.js process. No Docker required during development [homepage].
• Solid performance numbers. 20ms cold start and 0.6KB per actor are the right numbers for building thousands of concurrent lightweight stateful processes [README].
• Framework and runtime flexibility. Works with Node.js, Bun, Deno, Cloudflare Workers, and integrates with the standard frontend stack [homepage].

Cons

• Not for non-technical founders. This is developer infrastructure. If you don’t write TypeScript, this isn’t for you. There is no UI for creating actors, no no-code flow builder, nothing.
• Rivet Cloud pricing is opaque. The managed offering has no public pricing page. For founders evaluating total cost of ownership, this is a blocker before you build [homepage].
• Smaller ecosystem than the incumbents. Temporal has years of production battle-testing and a large community. Cloudflare Durable Objects have the full Cloudflare network behind them. Rivet is younger with a smaller community at 5,261 stars [merged profile].
• No third-party independent reviews found. Unlike Activepieces or n8n, Rivet hasn’t accumulated the kind of independent write-ups, Reddit threads, or comparison posts that help you verify vendor claims. You’re largely taking the benchmarks at face value.
• FoundationDB for enterprise durability is non-trivial. FoundationDB is a complex distributed database. If you need it, you need to know what you’re getting into.
• Global distribution requires Rivet Cloud or DIY. Self-hosted is single-region. If your users are global, you’re either paying for Cloud (unknown price) or running your own multi-region setup.

---

Who should use this / who shouldn’t

Use Rivet if:

• You’re a developer or technical founder building AI agents that need persistent conversation state, tool call scheduling, and per-agent isolation — and you want that to not cost $0.15/million requests on Cloudflare.
• You’re building a real-time collaborative app (shared documents, multiplayer, per-room chat) and want WebSockets plus state management to be one thing, not three.
• You’re currently paying for Temporal Cloud and your workload is steady enough that a fixed-cost VPS beats per-action pricing.
• You want the Cloudflare Durable Objects programming model without Cloudflare’s runtime restrictions or vendor dependency.
• You need Apache-2.0 licensing for commercial deployment or embedding in a product you resell.

Skip it (use Cloudflare Durable Objects) if:

• You’re already on Cloudflare Workers and your traffic is unpredictable or low-volume (the free tier is generous).
• You need true global edge — actors running in 300 PoPs within 10ms of every user. Self-hosted Rivet can’t match that.
• You prefer managed infrastructure with a known vendor backing it at enterprise scale.

Skip it (use Temporal) if:

• You need mature, battle-tested workflow orchestration with a large enterprise community.
• Your team already knows Temporal and you need its deterministic replay and time-travel debugging.
• You need the visibility and audit trail that Temporal’s workflow history provides for compliance.

Skip it entirely if:

• You’re a non-technical founder looking for automation, a CRM, a knowledge base, or any application-layer tool. Rivet is infrastructure, not an application.

---

Alternatives worth considering

• Cloudflare Durable Objects — the direct architectural equivalent, managed, global edge, tied to Cloudflare Workers runtime. Great if you accept the lock-in.
• Temporal / Temporal Cloud — mature durable workflow orchestration, more complex operationally, enterprise-grade. Better for long-running business processes than real-time stateful actors.
• Inngest — hosted durable function execution, simpler than Temporal, no self-hosted option with the same feature set. Usage-based pricing.
• PartyKit — similar actor-per-room model specifically for real-time multiplayer and collaborative apps. Less general-purpose than Rivet.
• Fly.io Machines — long-running lightweight VMs with fast cold starts and global deployment. More general-purpose (any workload), but you manage state yourself — no built-in actor primitives.
• Encore — opinionated backend framework with built-in infrastructure. More full-stack than Rivet but with vendor tie-in.

For a developer choosing between these: Rivet vs Cloudflare Durable Objects is the real fight for the stateful-actors use case. Pick Rivet if self-hosting and license freedom matter. Pick Durable Objects if global edge latency and Cloudflare’s operations team are worth the lock-in.

---

Bottom line

Rivet is the right answer to a specific question: “I want Cloudflare Durable Objects, but on infrastructure I control.” The actor model it implements is technically sound — 20ms cold starts, 0.6KB per-instance overhead, zero idle cost, single-binary self-hosting, and genuinely good built-in observability are not marketing claims that fall apart on inspection. The Apache-2.0 license means no commercial gotchas. For developers building AI agents or real-time collaborative apps who are watching their Cloudflare or Temporal Cloud bills grow, the math for self-hosting Rivet is favorable.

The honest caveats: Rivet Cloud’s pricing opacity is a problem for anyone planning at scale, the community is smaller than the incumbent platforms, and this is developer infrastructure with no accessibility for non-technical users. If you’re building AI products and want to own your execution infrastructure rather than rent it by the request, Rivet deserves a serious look — but go in knowing you’re adopting a younger project where you may have to dig deeper when things break.

---

Sources

No third-party independent reviews of Rivet (rivet.gg) were available at research time. All claims in this article are sourced from primary sources below.

Primary sources:

• GitHub repository and README — https://github.com/rivet-gg/rivet (5,261 stars, Apache-2.0 license)
• Official website — https://www.rivet.dev
• Rivet homepage — benchmarks and feature documentation — https://www.rivet.dev
• Rivet self-hosting documentation — referenced from homepage