sandbox.inevitable.fyi

👾

Spritessprites.sandbox.inevitable.fyi

Persistent little computers with names. The disk keeps everything, an idle sprite naps with its memory intact and wakes on the next request, and each one gets its own URL. This is the API the engine was born speaking.

exec + streaming
persistent disk
suspend / wake warm
checkpoints + restore
a URL per sprite
TCP proxy
services
network policy

base URL: https://sprites.sandbox.inevitable.fyi
SPRITE_TOKEN: your sandboxd key
your URL: https://<name>.sprites.sandbox.inevitable.fyi

Tested with sprites-py 0.7.1 through this URL. A sprite's URL wants your key until you set its url_settings.auth to "public". Names are global here, so pick something unlikely.

from sprites import SpritesClient  # pip install sprites-py

client = SpritesClient("<your key>",
                       base_url="https://sprites.sandbox.inevitable.fyi")
sprite = client.create_sprite("my-sprite")
print(sprite.command("uname", "-a").output().decode())
sprite.command("sh", "-c", "echo remember me > ~/note").run()
# ...walk away; it naps, and wakes with ~/note still there
client.delete_sprite("my-sprite")

import { SpritesClient } from '@fly/sprites'  // npm i @fly/sprites

const client = new SpritesClient('<your key>',
  { baseURL: 'https://sprites.sandbox.inevitable.fyi' })
const sprite = await client.createSprite('my-sprite')
const { stdout } = await sprite.exec('uname -a')
console.log(stdout)
await client.deleteSprite('my-sprite')

⚡

E2Be2b.sandbox.inevitable.fyi

Code-interpreter sandboxes with E2B's own in-guest daemon, envd, running inside. It's the real envd, not an imitation, so every feature of the SDK just works.

streaming commands
background processes
PTY + stdin
files
signed upload/download URLs
public ports
pause / resume
metrics
timeouts

E2B_API_URL: https://e2b.sandbox.inevitable.fyi
E2B_DOMAIN: e2b.sandbox.inevitable.fyi
E2B_API_KEY: your sandboxd key
your ports: https://<port>-<id>.e2b.sandbox.inevitable.fyi

Tested with e2b 2.52.0 (Python and JS): 26 of 26 checks pass. 2 vCPUs and 512 MiB per sandbox, like hosted E2B's base template.

import os
os.environ |= {
  "E2B_API_URL": "https://e2b.sandbox.inevitable.fyi",
  "E2B_DOMAIN":  "e2b.sandbox.inevitable.fyi",
  "E2B_API_KEY": "<your key>",
}
from e2b import Sandbox  # pip install e2b

with Sandbox.create() as sbx:
    r = sbx.commands.run("python3 -c 'print(6*7)'")
    print(r.stdout)                     # 42
    sbx.commands.run("python3 -m http.server 8080", background=True)
    print("https://" + sbx.get_host(8080))  # live on the internet

// E2B_API_URL, E2B_DOMAIN and E2B_API_KEY set as for Python
import { Sandbox } from 'e2b'  // npm i e2b

const sbx = await Sandbox.create()
const r = await sbx.commands.run("echo hello from Jake's house")
console.log(r.stdout)
await sbx.files.write('/home/user/hi.txt', '👋')
console.log(await sbx.files.read('/home/user/hi.txt'))
await sbx.kill()

▲

Vercel Sandboxvercel.sandbox.inevitable.fyi

Run commands, stream their logs, write files, expose a port on its own route, snapshot it, and boot a new one from the snapshot. The full Vercel Sandbox API, minus the bill.

runCommand (waited + detached)
streamed logs
env, cwd, sudo
files + mkdir
routes per port
snapshots
extendTimeout
kill signals

base URL: https://vercel.sandbox.inevitable.fyi/api
VERCEL_TOKEN: your sandboxd key
TEAM / PROJECT: any value (the SDK insists; we don't check)
your ports: https://<subdomain>.vercel.sandbox.inevitable.fyi

The JS SDK has vercel.com hardcoded, so it needs a 30-line preload that redirects its fetch: vercel-target.mjs. The Python SDK just takes a base_url.

# once: curl -O https://sandbox.inevitable.fyi/vercel-target.mjs
# VERCEL_TOKEN=<key> VERCEL_TEAM_ID=x VERCEL_PROJECT_ID=x \
# VERCEL_SANDBOX_URL=https://vercel.sandbox.inevitable.fyi/api \
#   node --import ./vercel-target.mjs app.mjs
import { Sandbox } from '@vercel/sandbox'

const sandbox = await Sandbox.create({ ports: [3000] })
const cmd = await sandbox.runCommand('sh', ['-c', 'echo it works'])
console.log(await cmd.stdout())
await sandbox.stop()

import asyncio, os
os.environ |= {"VERCEL_TOKEN": "<key>", "VERCEL_TEAM_ID": "x", "VERCEL_PROJECT_ID": "x"}
from vercel import sandbox          # pip install vercel-sandbox
from vercel.api import session
from vercel.sandbox import SandboxServiceOptions

async def main():
    opts = SandboxServiceOptions(base_url="https://vercel.sandbox.inevitable.fyi/api")
    async with session(service_options=[opts]):
        box = await sandbox.create_sandbox(persistent=False)
        r = await box.run_process("uname", ["-a"], capture_output=True)
        print(r.stdout)
        await box.stop(); await box.destroy()

asyncio.run(main())

☀

Daytonadaytona.sandbox.inevitable.fyi

Dev environments for agents: one-shot exec, code runs, long-lived sessions whose logs you can follow live, bulk file moves and preview links for anything you serve. It stops when idle and starts again when you need it.

exec + code run
sessions
live log follow
bulk upload/download
preview links
labels
auto-stop
stop / start

DAYTONA_API_URL: https://daytona.sandbox.inevitable.fyi/api
DAYTONA_API_KEY: your sandboxd key
previews: https://<port>-<id>.daytona.sandbox.inevitable.fyi

Tested with daytona 0.220.0 (Python and TypeScript): 22 of 22 checks pass. Private sandboxes' previews want their x-daytona-preview-token.

import os
os.environ |= {
  "DAYTONA_API_URL": "https://daytona.sandbox.inevitable.fyi/api",
  "DAYTONA_API_KEY": "<your key>",
}
from daytona import Daytona  # pip install daytona

sbx = Daytona().create()
print(sbx.process.exec("echo hi from $(hostname)").result)
print(sbx.process.code_run("print(sum(range(10)))").result)  # 45
print(sbx.get_preview_link(3000).url)
sbx.delete()

// DAYTONA_API_URL and DAYTONA_API_KEY set as for Python
import { Daytona } from '@daytonaio/sdk'

const daytona = new Daytona()
const sbx = await daytona.create({ language: 'typescript' })
const r = await sbx.process.executeCommand('echo hi')
console.log(r.result)
await sbx.delete()

🧪 COMING SOON

◆

Modalmodal.sandbox.inevitable.fyi

Python-first sandboxes. Your Modal code creates one with a single call, runs commands in it and reads their output as it streams, with a debian_slim image already warm and waiting. Same client, same code, nothing to deploy.

Sandbox.create
exec + streamed output
debian_slim, prebuilt
env + workdir
cpu / memory
timeouts
from_id
V1 + V2 sandboxes

MODAL_SERVER_URL: https://modal.sandbox.inevitable.fyi
MODAL_TOKEN_ID: anything
MODAL_TOKEN_SECRET: your sandboxd key

In the lab: a working spike with the modal 1.6.0 client, but it speaks Modal's private client API, so it isn't open to friends yet. Sandboxes and exec only; no Functions or custom images. Ask nicely and bring snacks.

import os
os.environ |= {
  "MODAL_SERVER_URL":   "https://modal.sandbox.inevitable.fyi",
  "MODAL_TOKEN_ID":     "friend",
  "MODAL_TOKEN_SECRET": "<your key>",
}
import modal  # pip install modal

app = modal.App.lookup("hello", create_if_missing=True)
sb = modal.Sandbox.create(app=app, image=modal.Image.debian_slim())
p = sb.exec("python3", "-c", "print(6*7)")
print(p.stdout.read())  # 42
sb.terminate()

Sandboxes,
but make it
homemade.

Pick your flavor

Spritessprites.sandbox.inevitable.fyi

E2Be2b.sandbox.inevitable.fyi

Vercel Sandboxvercel.sandbox.inevitable.fyi

Daytonadaytona.sandbox.inevitable.fyi

Three steps to 🎉

Get a key

Grab the script

Light it up

The fine print 🧾