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

Rivet Actors are durable processes for agents, workflows, and sandboxes.
12 ms cold starts, 72 KB per Actor, billions on one control plane.
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 worker process you already run, not in its own container or VM. A server that held hundreds of pods holds hundreds of thousands of Actors.
• 12 ms cold starts: A cold start includes scheduling the Actor, loading its state, 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 12 ms with nothing lost.
• SQLite or a POSIX filesystem per Actor: Every Actor gets a SQLite database or a POSIX filesystem, tiered to S3. Idle Actors cost nothing, so millions can sit parked with their state intact.
• 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.

Backend

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: Give every agent a durable process to live in.
• 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: 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

Features

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

• Fault tolerance by design: A worker going down reschedules its Actors elsewhere with their state intact. No replay harness or checkpointing of your own.
• 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 with no external dependencies 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

Run your agent infrastructure where your data already lives. The control plane is a single Rust binary: one process to install, monitor, and upgrade, on Kubernetes with the Enterprise Helm chart or as a systemd unit. Use Postgres or FoundationDB for persistence and tiered storage to S3. 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 workers on: Vercel • Railway • AWS ECS • AWS Lambda • GCP Cloud Run • Cloudflare • Kubernetes • Docker

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

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