Delete your Dockerfile.

Build OCI container images natively on RWX. Simpler to maintain than Dockerfiles, faster to build, smaller images, and easier to debug.

Read the docsTalk to an engineer

Distributed builds with automatic caching.

A Dockerfile is a serial recipe.

You hand-order COPY and RUN statements to coax the cache into hitting, you ship a build context to a single machine, and one upstream change invalidates every layer below it.

An RWX run definition is a graph. Tasks declare their inputs, the build fans out across machines, and the cache hits automatically where Dockerfiles miss.

FROM node:24.11.0-trixie-slim

WORKDIR /app
ENV NODE_ENV=production

COPY package.json package-lock.json ./
RUN npm ci --omit=dev

COPY . .

USER node
CMD ["node", "server.js"]
base:
  image: node:24.11.0-trixie-slim

tasks:
  - key: code
    call: git/clone 1.9.0

  - key: npm-install
    use: code
    run: npm ci --omit=dev
    filter: [package.json, package-lock.json]

  - key: image
    use: npm-install
    env: { NODE_ENV: production }
    run: echo "node server.js" | tee $RWX_IMAGE/command
Build image · main
StatusRunning
Runtime0s
Repositoryacme
Branchmain
Definitionimage.yml
TasksFlowTimelineProblems 0
code0s
npm-installCached
image0s

Simpler caching

No careful statement ordering. Each task names the files it depends on; touch something else and the cache still hits.

Distributed by default

No build context to ship to one machine. Independent tasks fan out across the cloud and run in parallel.

Pullable at every layer

Every task is a content-addressed OCI image. Pull any stage on your laptop to debug it.

The same build engine that runs your CI/CD, producing your container images.

Container builds run on the same RWX runtime as the rest of your pipeline. Distributed compute, content-based caching, and full observability. The image isn't a separate artifact built out of band — it's another task in the graph.

Every task is a pullable image.

RWX implements the OCI distribution spec. Pull any intermediate task as a container image. Debug a failing step locally or push the same step that your tests validated to a container registry.

❯

Caching that doesn't cascade.

In a Dockerfile, change one layer and everything below it rebuilds. RWX filters each task to just the files it depends on, so you can update a system package without rebuilding your node modules. Order your build in true dependency order without carefully sequencing COPY statements.

clone2s
rubyCached
gemsCached
nodeCached
node-modulesCached
app12s

Right-sized compute, per task.

A Dockerfile runs every step on one VM. RWX fans tasks out. Clone code with 2 cores. Compile with 16 cores. Stop paying biggest-machine prices for steps that don't need it.

clone2 vCPU · 4 GB
install-rust2 vCPU · 4 GB
cargo-clippy2 vCPU · 4 GB
cargo-build32 vCPU · 64 GB

Start building images in three steps.

Every task on RWX already produces an OCI container image.

❯_Read the getting started guide

Install RWX

Add the CLI and install the RWX skill.

❯ brew install rwx-research/rwx/rwx
❯ rwx skill install

Define your build

Describe your build in .rwx/ci.yml.

❯ claude -p "Migrate my Dockerfile to RWX"codex exec "Migrate my Dockerfile to RWX"cursor-agent -p "Migrate my Dockerfile to RWX"gemini -p "Migrate my Dockerfile to RWX"

Trigger a build

Launch a build directly from your local changes.

❯ rwx run ci.yml --target app

Delete your Dockerfile.

Start buildingTalk to an engineer