rivet-dev/rivet

Fast, high-density, scalable orchestration for agentic workloads.

Rivet Actors are durable processes for agents, workflows, and sandboxes.
6.9 ms cold starts, 72 KB per Actor, billions on one control plane.
One Rust binary and a bucket. No database, no message bus. Open source and self-hostable.

Quickstart • Documentation • Changelog • Discord • X

Getting Started

npx skills add rivet-dev/skills

What is Rivet?

Rivet is an orchestrator for agentic workloads. Where Kubernetes schedules pods, Rivet schedules Actors: long-lived processes with durable state, a SQLite database, a queue, realtime connections, and scheduling, each addressed by key.

Create one Actor per agent, per session, per user, or per tenant. Run it on plain Node.js, Bun, or Rust. Open source and self-hostable.

• 72 KB per Actor: An Actor lives inside a node process you already run, not in its own container or VM. A server that held hundreds of pods holds hundreds of thousands of Actors.
• 6.9 ms cold starts: A cold start includes scheduling the Actor, creating its storage, and serving the first request. No image pull, no container boot.
• Billions of Actors on one control plane: Actors are scheduled independently, so adding capacity means adding machines. The same control plane runs a thousand Actors or a billion.
• Hibernates when idle, wakes on demand: An idle Actor writes its state and unloads. The next request brings it back in 4.4 ms with nothing lost.
• Keep state with each Actor: Every Actor gets its own SQLite database and key-value storage. The control plane replicates writes to the disks of several instances before acknowledging them, then moves data to object storage in the background. Storage never runs out and the bucket never sits on the write path.
• One Rust binary and a bucket: There is no database to run and no message bus. Control plane instances are identical, run every service, and find each other through the bucket.
• Run code agents generate at runtime: Each piece of new, untrusted code gets an Actor of its own, with its own database and filesystem and no reach into anyone else's.
• Works with the tools you already use: Typed SDKs for your backend and React hooks for your frontend. No custom runtime, so your existing packages, tooling, and tests work unchanged.

import { actor } from "rivetkit";
import { db } from "rivetkit/db";
const agent = actor({
  // Per-Actor SQLite database, persisted across restarts and hibernation
  db: db({
    onMigrate: async (db) => {
      // Apply the SQLite schema
      await db.execute(CREATE TABLE IF NOT EXISTS messages (role TEXT, content TEXT));
    },
  }),
actions: {
    chat: async (c, text: string) => {
      // Durably save the message
      await c.db.execute("INSERT INTO messages VALUES (?, ?)", "user", text);
      const messages = await c.db.execute("SELECT role, content FROM messages");
const response = streamText({ model: openai("gpt-5"), messages });
// Stream tokens to every connected client for multiplayer
      for await (const delta of response.textStream) {
        c.broadcast("token", delta);
      }
// Durably save the response
      await c.db.execute("INSERT INTO messages VALUES (?, ?)", "assistant", await response.text);
    },
  },
});

Client (frontend or backend)

// Connect to an Actor
const agent = client.agent.getOrCreate("agent-123").connect();
// Listen for realtime events
agent.on("token", delta => process.stdout.write(delta));
// Call an action on the Actor
await agent.chat("how many r's in strawberry?");

Actor types

Every product Rivet ships is an Actor, scheduled by the same control plane.

• Actors: Long-lived processes with state, realtime, and scheduling built in.
• Agents: A durable process per agent, with memory that survives restarts.
• Workflows: Multi-step operations that replay instead of starting over.
• Sandboxes (agentOS): A filesystem, shell, and network for code you did not write.
• Dynamic Apps (preview): A backend per user, deployed the moment it is generated.

Built for everything agents need

• Coding agents: One Actor per agent with a durable process, a sandbox, and state that survives restarts.
• Agent app builders: Your product generates a whole backend for a user; each one deploys as its own Actor that scales to zero.
• Company-specific agents: Run agents inside your VPC next to Postgres, your APIs, and your helpdesk, so no data leaves your cloud.
• Personal agents: A long-lived Actor per user with memory, scheduling, and reminders, online for months.
• Realtime apps: One Actor per document, room, or channel broadcasting changes to every connected client.

How Actors compare to Kubernetes

| | Rivet Actor | Kubernetes pod | |---|:---:|:---:| | Cold start | 6.92 ms | ~6 s | | Wake from hibernation | 4.37 ms | ~6 s (new pod) | | Memory per instance | 72.4 KB | ~200 MB | | Memory while idle | 0 MB (hibernates) | Always resident | | Scale | Billions of Actors on one control plane | ~5k nodes per cluster | | Storage | Bottomless SQLite, replicated and moved to your bucket | Persistent volume per pod |

Features

Routing, scheduling, types, and telemetry, built in.

• Fault tolerance by design: A node going down reschedules its Actors elsewhere with their state intact. No replay harness or checkpointing of your own.
• Keep state with each Actor: Every Actor gets its own SQLite database and key-value storage. The control plane replicates writes and moves data to object storage, so you never size a disk for an Actor.
• Multi-region: Place Actors near the users and data they serve, and route requests to wherever each one currently lives.
• HTTP & WebSocket networking: Address an Actor directly over HTTP or hold a live WebSocket to it. No queue or broker in between.
• End-to-end type safety: Actor definitions generate their own client types, so a signature change breaks the build rather than production.
• React SDK: First-party hooks that subscribe a component to an Actor's state and keep it live as the Actor updates.
• OpenTelemetry & observability: Traces, metrics, and structured logs emitted in OTel format, into the collector you already run.
• Single Rust binary: The control plane ships as one static binary. Run a few identical instances behind a load balancer with an object storage bucket: no database and no message bus to stand up first.
• Cron & scheduling: Wake an Actor on a schedule or at a timestamp it sets for itself, without a separate scheduler.
• Sleeps when idle: Idle Actors release their resources and wake with durable state intact when the next request arrives.
• Actor-to-Actor calls: Actors address each other by key and call across the cluster as if the other one were local.
• No Kubernetes operator: One control plane behind a load balancer, speaking plain HTTP inside your VPC. No CRDs, no operator, no service mesh to keep alive.
• Open source: Apache 2.0, self-hostable in full. The managed service runs the same control plane you can run yourself.

Deployment Options

npm install rivetkit@next

Every option runs the same binary. The only difference is who operates it. Self-hosting means running four things: identical control plane instances (one to try it, three or more in production), a persistent disk per instance that holds recent writes and the instance's identity, one bucket per cluster on S3, Google Cloud Storage, Azure Blob Storage, or any S3-compatible store, and the nodes that run your Actors. There is no database to run and no message bus. Local dev matches production: the same binary, APIs, and control-plane behavior from laptop to production.

Open source, permissively licensed: Apache 2.0 means you own your infrastructure. The managed service runs the same control plane you can run yourself. Talk to an engineer →

Works with the tools you already use

Typed SDKs for your backend and React hooks for your frontend. Rivet runs on native Node.js and Bun with no custom runtime, so your existing packages, tooling, and tests work unchanged.

Deploy nodes on: Docker Compose • Kubernetes • VM & bare metal • Hetzner • AWS ECS • Railway • Render

Frameworks: React • Next.js • Hono • Elysia • tRPC • Effect

Runtimes: Node.js • Bun • Rust

Tools: Vitest • OpenTelemetry • Pino • AI SDK • OpenAPI • AsyncAPI

Request an integration →

FAQ

Projects in This Repository

| Project | Description | |---------|-------------| | RivetKit TypeScript | Client & server library for building Actors | | RivetKit Rust | Rust SDK | | RivetKit Python | Python client (experimental) | | RivetKit Swift | Swift client (experimental) | | Control Plane | Rust control plane that schedules, routes, and persists Actors | | ↳ Pegboard | Actor scheduling & networking | | ↳ Gasoline | Durable execution engine | | ↳ Guard | Traffic routing proxy | | ↳ Epoxy | Multi-region KV store (EPaxos) | | Dashboard | Inspector for debugging Actors | | Documentation | Source for rivet.dev/actors/docs | | Examples | Runnable examples |

Community

• Discord - Chat with the community
• X/Twitter - Follow for updates
• Bluesky - Follow for updates
• GitHub Discussions - Ask questions
• GitHub Issues - Report bugs
• Talk to an engineer - Discuss your use case

License

Apache 2.0