the localhost hyperscaler

slab

Pour a foundation on the machines you already own. One daemon gives you containers, ingress, databases, secrets, public tunnels, one-shot jobs, and systems that span your laptop, the mac mini in the closet, and a $5 VPS. No cloud account. No YAML.

curl -fsSL https://runslab.run/install | bash

needs docker · node ≥ 20 · git · the installer checks and tells you the exact fix

Open in GitHub Codespaces deploy to aws ↗

this is the dashboard's actual language: every app a rack unit, flip one open for its board · skinnable (this page too: try the switcher ↑)

see the real thing move: the demo lives in the README · rack breathing, a board flipped open, the two-node fleet

The elements

three nouns · three verbs · one verb per noun
U01
appsslab deploy
any repo with a Dockerfile, zero config; services stay up, functions scale to zero
$ slab deploy owner/repo
deployed repo -> http://repo.localhost:8080
U02
jobsslab run
run to completion; exit code back, logs kept, timeout reaps runaways
$ slab run . -- npm test
scheduling on garage (0 active jobs)
test-a1b2 succeeded in 41s
U03
systemsslab up
apps wired on a private network; private members get no host port at all
$ slab up ./system.toml
  game       -> http://game.localhost:8080
  scoreboard -> @ garage (via trunk)
slabone manifest · toml · git-trackable

apps and jobs are the vertices; wires are the edges. a system is a graph. a node is a daemon, and it carries a set of systems. that's the whole surface. nothing to memorize, nothing to hold wrong, for you or for an agent.

Slab types

how a system carries load

Flat

No wires. Members rest directly on the ingress: maximum clear ceiling height.

no beams

One-way

Load travels one direction. Pipelines, feeders, ingest chains.

directed

Two-way

Bending in all directions: members that call each other.

mutual

Waffle

Spans machines. The trunks are the utilities concealed in the voids.

multi-node

the dashboard stamps every system's nameplate with its type, computed from the wire graph, not declared. examples/ ships one of each. the types are computed from the edges: no wires is flat, acyclic is one-way, cyclic is two-way, and a system carried by more than one node is a waffle. jobs arrive and leave, so the graph breathes. what the daemon can compute, it can guarantee: the type stamp is a computation, a patched wire redeploys exactly its caller, and an agent traverses the topology instead of guessing at it.

Specifications

what the daemon carries
slab · model v0continuous duty
ingressapp.localhost:8080 host-header routing, wake-on-request
functionsscale to zero after idle, woken by the next request
postgrespostgres = true → DATABASE_URL appears, one db per app
secretsoutside the manifest, injected at deploy, names-only reads
tunnelsslab expose → public https, no account, no domain
wiresenv bindings between members; patching redeploys the caller
trunkssystems span machines; private members included, byte-identical urls
clusternamed nodes, --node garage targeting, --node any scheduling
fleetzoom out: every node a band, dead nodes shown honestly
zero manifestno slab.toml? name from the repo, port from EXPOSE
cloud targets--target aws: services → App Runner, functions → Lambda; your account, no stored keys
skinsstereo rack · flat console · or one css file of your own
upgradesslab upgrade — pull, rebuild, restart; state survives

Built for agents

mcp, first-class

Agents create infrastructure faster than humans can track it. The platform must make running things legible, bounded, reversible.

slab ships an MCP server: an agent takes a repo to a running, routable app, or drops a sandbox job inside a system's private network to probe real members over real wiring, without ever learning Docker. Timeouts reap what nobody remembers.

the tool surface →

agent session
› slab_run { systems: ["arcade"], image: "alpine:3",
           command: ["wget","-qO-","http://scoreboard:4000/health"] }
{ state: "succeeded", exitCode: 0, logs: "ok" }
› scoreboard is healthy; patching the ssl bug, redeploying…
› slab_deploy { name: "scoreboard" }
{ state: "running", version: 8 }
› system arcade repaired; probe rerun, all members answering