Deploy a Cell. Get a whole backend.

Write a cell.js, run ribo deploy, get a live URL. SQL storage, object storage, scheduling and sensor ingest attach as named bindings on env, declared in a few lines and injected at dispatch. No servers, no config, no cold starts.

start building → read the docs
A Cell with four bindings attached A central Cell running cell.js, connected to four bindings: c3 as env.DB, g7 as env.FILES, pulse as a cron schedule, and synapse as env.SENSOR. cell.js c3 env.DB g7 env.FILES pulse [[pulse]] synapse env.SENSOR
Fig. 1One Cell, four bindings, one deploy. The outlined circle is synapse: an inlet rather than a store, and the same open circle the tissue mark has always carried.
Fig. 2A real ribo deploy. Every binding in Fig. 1 is provisioned and attached in the same run that puts the code on a URL.

Five primitives, one runtime

Compute, structured data, object storage, scheduling, and sensor ingest: each a named binding on env, declared in a few lines of ribo.toml, injected at dispatch. No keys in code, no separate dashboards to wire together.

Cells
compute
JavaScript & WASM on a live URL. Each Cell runs in a V8 isolate. Nothing to provision, nothing to scale, no cold starts.
the runtime everything else attaches to
c3
sql · sqlite
A SQL API backed by SQLite: exec, batch, prepare, bind, and native vector search. Persistent storage your Cell reads and writes every request.
binds as env.DB
g7
object storage
S3-compatible object storage. Serve files, store state, cache embeddings. One line of config, signed for you.
binds as env.FILES
pulse
scheduler
A cron scheduler in one [[pulse]] block. Fire your Cell on any 5-field POSIX schedule, UTC. No worker to babysit.
declared as [[pulse]]
synapsenew
sensor ingest · tissue sense
Any device in over MQTT, CoAP, or HTTPS, and a clean sensor event out to a Cell. Ingest, store in c3, chart it live. The doorway for tissue Sense.
binds as env.SENSOR

One substrate, many shapes

The same Cell + binding model is a backend, a data pipeline, a sensor dashboard, or a sandbox for someone else's code. Agents are one thing you can build here, not the only thing.

APIs & backends

REST and JSON endpoints with a database and object storage in the same deploy. Web-standard Request & Response. No framework lock-in.

uses Cells · c3 · g7

AI agents

LLM loops with SQL memory and vector search built in. V8 isolates start in under a millisecond, so a thousand sub-agents cost a fraction of a container.

uses Cells · c3 · pulse

Data pipelines

Webhook- or cron-triggered ETL: receive an event, transform it, write to c3, stash blobs in g7. Bursty, short-lived work without a container idling.

uses pulse · c3 · g7

Sensor dashboards

Point a device at synapse, store readings in c3, and render a live dashboard from the very same Cell that ingested them. That's tissue Sense.

uses synapse · c3 · Cells

Tenant-isolated code

Let your users run custom logic, Zapier-style steps or app extensions, each sealed in its own hardened isolate, unable to see any other tenant.

uses Cells · vault

Sovereign & on-premsoon

The whole stack is designed to be portable: run the same Cells on tissue, or bring your own infrastructure so your data never has to leave the building. On the roadmap.

uses the whole platform

Idea to live URL in seconds

No Docker. No IAM policies. No YAML sprawl. Two files and one command.

  1. 1
    Write a cell.js

    Export a fetch handler. Plain Web-standard Request & Response.

  2. 2
    Declare bindings in ribo.toml

    Add c3, g7, pulse, or a synapse sensor. Each becomes a named binding on env.

  3. 3
    ribo deploy

    Uploaded, addressed, and live on both edges in a couple of seconds.

Or drive it from an agent: Claude, Cursor, any MCP client
cell.jsribo.toml
// cell.js: an endpoint with SQL memory export default { async fetch(request, env) { const { results } = await env.DB.exec( "select reply from memory limit 1" ); return new Response(results[0].reply); }, };

A sign-in you don't buildnew

Every Cell is public by default: anyone with the URL can call it. A gate narrows that to the people you choose — a few lines in ribo.toml, enforced at the edge before your Cell runs. Teammates sign in with a work address, a client follows a capability link you can revoke, everyone else meets a hosted sign-in page. No auth code in your Cell: the visitor arrives as a verified header, x-tissue-gate-email.

Audiences, capability links, sessions, revocation: the gate docs
A gated Cell admitting one visitor and turning another away A gate block from ribo.toml is wired to a pore in the Cell's membrane. A wire from sam@yourco.com passes through the pore to cell.js; a wire from an anonymous visitor stops at the membrane and is redirected to a hosted sign-in page. [gate] audience = "domain" domains = ["yourco.com"] sam@yourco.com anyone else cell.js sign in hosted sign-in page
Fig. 3The gate is the Cell's membrane: declared in ribo.toml, selectively permeable, checked at the edge. Traffic the policy doesn't admit turns toward the sign-in page and never reaches cell.js.

A backend that ships whole

No cold starts
V8 isolates spin up in under a millisecond. The first request answers as fast as the millionth.
isolate start <1ms · no container to warm
Batteries included
Data, storage, scheduling, and sensor ingest ship with the runtime. No third-party dashboards, no glue code.
one bill · one CLI · one login
Yours to move
Everything flows through ribo, and the runtime underneath is open: the same Cells are designed to run on hardware you control.
V8 · SQLite · S3, no proprietary lock

Ship your first Cell today.

Free to start. No credit card. A whole backend is one command away.

$ribo deploy
get started → read the docs