Moving from Runloop to Promigence

This notice opens Runloop's documentation: "Runloop is winding down its services. Support for existing customers continues through November 13, 2026 at 11:59 PM PT." (Runloop transition guides, read 25 Oct 2026)

If your agents run in Runloop devboxes, this guide moves them to Promigence sandboxes. You get a map from each Runloop part to what replaces it, one program written both ways in TypeScript and Python, a blueprint rebuilt from its Dockerfile, the checks that prove the move, and both price lists. When Promigence has nothing to match a Runloop feature, the tables say so.

Before you start#

Install the CLI, sign up, then add the SDK your code uses:

npm i -g promigence              # the CLI
promigence signup                # in your browser: sign up, then authorize the CLI
promigence credits claim         # claim your free credit before the first run
npm i @promigence/sdk            # the TypeScript SDK (Node.js 20 or newer)
pip install promigence           # the Python SDK

Both SDKs read PROMIGENCE_API_KEY, or the key promigence signup stored. Where your Runloop CI read RUNLOOP_API_KEY, set PROMIGENCE_API_KEY to a key from promigence keys create.

A new account runs 20 sandboxes at once, each for up to an hour, on sizes up to large (8 vCPU), with 20 GB of data out a month. If your Runloop fleet needs more, email support@promigence.ai before you move it.

What each Runloop part becomes#

The first table covers what most Runloop code calls. Where the Python name differs, it follows the TypeScript one in parentheses.

The rest of Runloop's features, most of which have no Promigence equivalent:

The same program, side by side#

Each Runloop cell below quotes a page of Runloop's docs, read 25 Oct 2026: the quickstart, the guides to commands and files, the snapshot and lifecycle pages, and the Python SDK reference for create_devbox. Next to each one, the Promigence cell does the same step.

TypeScript:

Python, with the async SDKs on both sides:

Here is the whole Promigence program in TypeScript, which also starts a second sandbox from the snapshot and cleans up after itself. Run it as an ES module, for the top-level await:

import { PromigenceClient, Sandbox } from "@promigence/sdk";

const client = new PromigenceClient(); // reads PROMIGENCE_API_KEY, or the key signup stored
const sbx = await Sandbox.create({ client, spendCap: 1 });
try {
  const result = await sbx.commands.run("echo 'Hello from Promigence'");
  console.log(result.stdout, result.exitCode);

  await sbx.files.write("/tmp/main.py", 'print("Hello, World!")');
  console.log(await sbx.files.read("/tmp/main.py"));

  // A snapshot of the sandbox as it is now: new sandboxes can start from it
  const snap = await client.sandboxes.snapshot(sbx.sandboxId);

  await sbx.pause();
  await sbx.resume();
  console.log(await sbx.files.read("/tmp/main.py")); // still there

  const copy = await Sandbox.create(snap.snapshot_id, { client, spendCap: 1 });
  console.log(await copy.files.read("/tmp/main.py"));
  await copy.kill();
  await client.snapshots.delete(snap.snapshot_id);
} finally {
  await sbx.kill();
}

And the same in Python:

import asyncio

from promigence import AsyncPromigence, AsyncSandbox


async def main() -> None:
    async with AsyncPromigence() as client:  # reads PROMIGENCE_API_KEY, or the key signup stored
        sbx = await AsyncSandbox.create(client=client, spend_cap=1)
        try:
            result = await sbx.commands.run("echo 'Hello from Promigence'")
            print(result.stdout, result.exit_code)

            await sbx.files.write("/tmp/main.py", 'print("Hello, World!")')
            print(await sbx.files.read("/tmp/main.py"))

            # A snapshot of the sandbox as it is now: new sandboxes can start from it
            snap = await client.sandboxes.snapshot(sbx.sandbox_id)

            await sbx.pause()
            await sbx.resume()
            print(await sbx.files.read("/tmp/main.py"))  # still there

            copy = await AsyncSandbox.create(snap["snapshot_id"], client=client, spend_cap=1)
            print(await copy.files.read("/tmp/main.py"))
            await copy.kill()
            await client.snapshots.delete(snap["snapshot_id"])
        finally:
            await sbx.kill()


asyncio.run(main())

spendCap: 1 caps what the sandbox may spend at one dollar. Leave it out and the sandbox is capped at what its full timeout costs (on the trial, at the credit left).

Moving an environment#

A Runloop blueprint becomes a snapshot that you build once and start sandboxes from by its alias. Builds take an image or a Dockerfile, your setup steps and a verify command. If the verify command does not exit 0, nothing is stored. A build is billed per second while it runs, whether it verifies or not, up to $0.17 at the default small size.

Runloop's blueprint guide uses launch_commands to install jq (Runloop blueprints, read 25 Oct 2026). Every launch command becomes a --setup step, and the verify command proves the step worked:

promigence snapshot create --image ubuntu:24.04 \
  --setup "apt-get update && apt-get install -y jq" \
  --verify "jq --version" \
  --alias docs-template --wait --wait-timeout 10m

A blueprint built from a Dockerfile, with rli blueprint from-dockerfile --name my-agent-env --dockerfile ./docker/Dockerfile --build-context ., keeps its Dockerfile. First change any FROM runloop: line. That prefix names Runloop's own images and blueprints (Runloop Dockerfile customization, read 25 Oct 2026), so start from a public image instead and install what your code used from Runloop's starter image. The Runloop devbox overview lists what that image includes.

# was: FROM runloop:runloop/starter-x86_64
FROM ubuntu:24.04
RUN apt-get update \
 && apt-get install -y --no-install-recommends ca-certificates curl git jq python3 python3-pip \
 && rm -rf /var/lib/apt/lists/*

Then build it, with the same build context:

promigence snapshot create --dockerfile ./docker/Dockerfile --context . \
  --verify "python3 --version && jq --version" \
  --alias my-agent-env --wait --wait-timeout 10m

Start sandboxes from the alias with Sandbox.create("my-agent-env", { spendCap: 1 }) in TypeScript, AsyncSandbox.create("my-agent-env", spend_cap=1) in Python, or promigence fork --snapshot my-agent-env --count 1 --cap 1. Other blueprint settings move to flags of snapshot create:

Promigence cannot import a Runloop snapshot. To keep data from one, start a temporary devbox from it and export the directories you need, as Runloop's transition guides suggest (Runloop transition guides, read 25 Oct 2026). Pack them with tar in that devbox and fetch the archive with file.download. Unpack it on your machine, copy it into a sandbox with promigence files put --recursive, and keep the result with promigence sandbox snapshot SID --alias NAME.

Check the move#

Runloop's guides for moving devboxes to Tensorlake, Modal and Freestyle start with a script that checks command execution and UTF-8 file round trips, then extend the checks with a validation plan for the workload (Runloop transition guides, read 25 Oct 2026). Run the same checks on Promigence before you switch any traffic:

1. Commands: for a command that succeeds and for one that exits 7, the exit code matches and so does the output on both streams.
2. UTF-8 text: a file with non-ASCII characters reads back exactly as written.
3. Binary data: bytes with a NUL in them read back unchanged.
4. Modes and links: after chmod 750 and ln -s, stat -c %a and readlink show the mode and the link you set.
5. Shell state: no environment variable or working directory carries over between commands. Pass cwd and envs where your Runloop code used a named shell.
6. User and paths: id -un, echo $HOME and pwd give what your code expects. On Runloop the default user is user, with its home at /home/user.
7. Pause and resume: a file written before a pause is there after the resume, and nothing your resume logic starts is running twice.
8. Snapshots: a sandbox started from a snapshot has the same files, the same modes and the same links.
9. Network: when you used a network policy, an allowed host answers and a host outside the list is refused.
10. Clean-up: promigence sandbox list --state ready,running,paused lists none of your test sandboxes, and the test snapshots are gone.

This script runs checks 1 to 4 and checks 7 and 8 in one go, printing a line per check and exiting non-zero if any fails:

import asyncio
import uuid

from promigence import AsyncPromigence, AsyncSandbox


async def main() -> None:
    token = uuid.uuid4().hex
    path = f"/tmp/transition-probe-{token}"
    text = f"transition probe {token}: café, naïve, 東京\n"
    checks: dict[str, bool] = {}
    async with AsyncPromigence() as client:
        sbx = await AsyncSandbox.create(client=client, spend_cap=1)
        try:
            r = await sbx.commands.run("printf 'stdout-probe\\n'; printf 'stderr-probe\\n' >&2")
            checks["command exit 0, stdout, stderr"] = (r.exit_code, r.stdout, r.stderr) == (0, "stdout-probe\n", "stderr-probe\n")
            r = await sbx.commands.run("exit 7", throw_on_exit=False)
            checks["command exit 7"] = r.exit_code == 7

            await sbx.files.write(f"{path}.txt", text)
            checks["UTF-8 file round trip"] = await sbx.files.read(f"{path}.txt") == text
            data = b"binary\x00fixture"
            await sbx.files.write(f"{path}.bin", data)
            checks["binary file round trip"] = await sbx.files.read(f"{path}.bin", format="bytes") == data
            await sbx.commands.run(f"chmod 750 {path}.bin && ln -s {path}.bin {path}.link")
            manifest = f"stat -c %a {path}.bin && readlink {path}.link"
            r = await sbx.commands.run(manifest)
            checks["file mode and symlink"] = r.stdout == f"750\n{path}.bin\n"

            await sbx.pause()
            await sbx.resume()
            checks["files after pause and resume"] = await sbx.files.read(f"{path}.txt") == text

            snap = await client.sandboxes.snapshot(sbx.sandbox_id)
            copy = await AsyncSandbox.create(snap["snapshot_id"], client=client, spend_cap=1)
            try:
                checks["files in a sandbox started from the snapshot"] = await copy.files.read(f"{path}.txt") == text
                r = await copy.commands.run(manifest)
                checks["mode and symlink in that sandbox"] = r.stdout == f"750\n{path}.bin\n"
            finally:
                await copy.kill()
                await client.snapshots.delete(snap["snapshot_id"])
        finally:
            await sbx.kill()
    for name, ok in checks.items():
        print("PASS" if ok else "FAIL", name)
    raise SystemExit(0 if checks and all(checks.values()) else 1)


asyncio.run(main())

The same calls exist in the TypeScript SDK, under the names in the tables above.

Prices#

Each column comes from that company's own pages, read on 25 Oct 2026: Runloop pricing on one side; on the other, the Promigence pricing section, pricing page and FAQ, with the build price from the quickstart, the paused rule from Limits and notices and the storage rule from the errors reference.

Help with the move#

Write to support@promigence.ai with what you run on Runloop today (the SDK and its version, your blueprints, snapshot sizes and network rules), and we will plan the move with you. The founder will help with your migration personally.

Sources#

Every page below was read on 25 Oct 2026. Prices and features change, and each company's own page is the authority.

If anything on this page is out of date or wrong, write to support@promigence.ai and we will correct it and note the date.