Skip to main content
Sign In
Dynamic AppsPreview

Deploy AI-generated apps for your users.

Every app runs as an isolated, durable instance. 22 MB of memory while serving, zero while idle. Deploy on any cloud. Supports frontends, REST APIs, multiplayer, SQLite, workflows, and more.

Start the quickstart
TS
App.tsx

Generate

An LLM writes the files

await deployApp({
  appId: "pied-piper",
  files,
});

Deploy

One call from your code

GET /apps/pied-piper200
acme.dev/apps/pied-piper

Route

Live on your domain

An LLM generates App.tsx, api.ts, and server.js. Your code calls deployApp with those files. A GET request to acme.dev/apps/pied-piper returns 200 and the page opens in the browser.

Runs in your backend, not another SaaS.

A library, not a platform. It serves the apps your users generate alongside the rest of your API, so you keep full control over routing, auth, and data.

An app per user

Address each app by ID. Every user, tenant, or session gets a deployment of its own.

Isolated by default

Each app runs in its own agentOS VM. Tenants share no filesystem, memory, or crashes.

Scales to zero

A running app takes 22 MB of memory. An idle one takes none.

Full Node.js or Python

Powered by agentOS with secure Node.js and Python runtimes, so generated apps can use any npm or PyPI package.

server.ts

Generate

An LLM writes the app as a set of files. Any model, any framework.

import { anthropic } from "@ai-sdk/anthropic";
import { generateText, Output } from "ai";
import { z } from "zod";
 
const { output } = await generateText({
  model: anthropic("claude-sonnet-4-5"),
  output: Output.object({
    schema: z.object({ files: z.record(z.string(), z.string()) }),
  }),
  prompt: "Build a team board as a complete web app.",
});

Deploy

One call builds the files and releases them as an isolated instance.

import { deployApp } from "@rivet-dev/dynamic-apps";
 
await deployApp({
  appId: "pied-piper",
  files: output.files,
});

Route

Your Hono server serves every deployed app at /apps/:appId.

import { serve } from "@hono/node-server";
import { appsRouter } from "@rivet-dev/dynamic-apps";
import { Hono } from "hono";
 
const server = new Hono();
server.route("/apps", appsRouter);
 
serve({ fetch: server.fetch, port: 3000 });
Read the documentationView the full example on GitHub

Comes with the infrastructure real apps need.

Every generated app gets durable SQLite, background jobs, cron, and realtime out of the box. Nothing extra for you to provision.

REST APIs & frontends Serve HTTP APIs and generated interfaces from the same app. SQLite Store durable relational data in an actor-owned SQLite database. Workflows & queues Run durable jobs that sleep, retry, and resume, plus ordered queue processing. Crons & schedules Schedule recurring work that runs even while the app is idle. Multiplayer Share realtime state between every user connected to an app. Static sites Serve a directory with an index.html directly, no server code required.

Your server, your rules.

Requests reach your Node.js backend first, so your routing, middleware, and auth apply. The apps router then hands each request to the agentOS VM running that app, in the same process. No extra hop.

Read about routing, authentication, and deploying apps.

Broken builds never ship.

A failed build returns TypeScript diagnostics the agent uses to repair the files and deploy again. The active release keeps serving the whole time.

Read about deploying apps or view the AI App Builder example.

GenerateBuildReleasev1 livetype errors

Full isolation, powered by V8 and WebAssembly.

Every app builds and serves inside its own agentOS sandbox: a V8 isolate for the JavaScript, WebAssembly for the Linux-like environment around it. The same boundary applies while a build runs and while requests are served.

Read about the agentOS security model and resource limits.

See inside every app.

Deployed apps run as Rivet Actors, so the dashboard shows their data, jobs, events, and actions live.

SQLite viewer

Browse and query each app's SQLite data in realtime, across every deployment.

Workflow state

Inspect the progress, steps, and retries of jobs running inside an app.

Event monitoring

Follow actions, connection events, and application logs while an app serves traffic.

REPL

Debug a live app by calling its actions and subscribing to its events from the dashboard.

Rivet dashboard inspecting a deployed app, showing Actor state, events, and callable actions

One stack under every app.

Actors

Every deployed app runs as Rivet Actors, which provide identity, durable state, queues, and scale to zero.

Product overview

agentOS

Builds and serves each app in an agentOS VM with files, processes, and networking.

Product overview

Workflows

Adds recorded steps, retries, and replay when a generated app runs multi-step work.

Product overview

Develop locally. Deploy your way.

Dynamic Apps is a library, not a hosted platform. Run it anywhere and customize the server, routing, authentication, and deployment flow.

Local

Install Dynamic Apps and run it locally while you build.

Open the quickstart

Rivet Cloud

Deploy Dynamic Apps on Rivet Cloud with managed infrastructure and persisted Actor data.

Open the dashboard

Self-Host

Run the open-source Rivet control plane as a Rust binary or container on your infrastructure.

Read self-hosting docs

Frequently asked questions

An app for every user.

Deploy isolated, durable instances for the software your agents generate. They scale to zero and wake on demand.

Documentation Talk to an engineer