Disposable compute for autonomous agents

Give your AI agent a disposable computer.

Fresh isolated MicroVM per call, hard-purged after every run. Full internet egress. Every runtime and common package pre-installed.

Protects your machine from the code your agent writes. Doesn't control what data the agent can access — that's your framework's job.

Read the docs

no account required

⠋ running in isolated MicroVM...

{ "exit_code": 0, "stdout": "4294967296\n", "execution_ms": 247, "state_purged": true, "note": "exit 0 in 247ms — sandbox purged, nothing survived.", "scratchrun": { "isolation": "microvm", "born": "2026-07-31T18:42:01.203Z", "died": "2026-07-31T18:42:01.450Z", "lifetime_ms": 247, "trace_left": "none", "epitaph": "ran clean, left nothing behind." } }

Run this. No signup. No key.

Real output

Think with code. Get artifacts back.

The real customer is an agent that fetches data, runs analysis, and returns a chart — all in one call.

Agent-written Python

# fetch 90 days of S&P 500 prices,
# compute 20-day moving average,
# return chart PNG + daily returns CSV

import requests, pandas as pd
import matplotlib.pyplot as plt
from io import StringIO

r = requests.get("https://query1.finance.yahoo.com/...")
df = pd.read_csv(StringIO(r.text), parse_dates=["Date"])
df["MA20"] = df["Close"].rolling(20).mean()

fig, ax = plt.subplots(figsize=(10, 4))
ax.plot(df["Date"], df["Close"],
       color="#4ade80", linewidth=1.5, label="Price")
ax.plot(df["Date"], df["MA20"],
       color="#fbbf24", linewidth=1.5, label="20d MA")
plt.savefig("price_chart.png", dpi=150)
df.to_csv("returns.csv", index=False)

Request

{
  "runtime": "python3.12",
  "code": "...",
  "return_files": ["price_chart.png", "returns.csv"]
}

// response.files["price_chart.png"] = base64 PNG
// 88 KB chart · 9 KB CSV · exit 0 · ~3.4s

Returned chart (price_chart.png)

price_chart.png via return_files

One call. 90 days of price data, 20-day moving average, returned as a chart and CSV, environment wiped. "state_purged": true

How it works

One call. No setup. No cleanup.

No install, no running daemons, no teardown scripts. POST code, get output. The rest disappears.

POST your code

Send runtime + code. Optionally attach files, inject env vars for secrets, or request return_files as base64 in the response.

Runs in a fresh MicroVM

A new isolated MicroVM boots, runs your code as a subprocess, and kills the process group on timeout. Zero shared state with any other execution.

Get output. VM gone.

You receive stdout, stderr, exit_code, and any requested files. The MicroVM is terminated immediately — never suspended, never reused.

No session. No cleanup. No state. — "state_purged": true is always true. It's not a config option.

Isolation

Your machine isn't involved.

The code your agent writes runs somewhere else, in a box that disappears. Here's exactly what that means.

MicroVM per call — not a shared container

Each execution gets its own MicroVM with hardware-level isolation. No neighbor processes, no shared filesystem, no shared memory between callers.

Hard-purged, not suspended

TerminateMicroVM is called unconditionally after every execution. The VM is destroyed, not paused. No state ever persists between calls.

RFC 1918 + cloud metadata always blocked

10.x, 172.16–31.x, 192.168.x, and 169.254.x.x are blocked at the network layer regardless of settings. The agent can't reach your home network or AWS metadata.

Read-only system filesystem

The runtime image is mounted read-only via OverlayFS. /tmp is RAM-backed (tmpfs) and destroyed on termination. No writes hit a persistent disk.

Honest scope: ScratchRun protects your machine from the code the agent writes. It doesn't control what data your agent sends to external services — that's your framework's job. "Safe execution," not "safe agents."

/v1/demo — free to try.

No account. No key. Same isolated MicroVM — lower limits, rate limited.

"I wired ScratchRun into my harness and ran 47 executions overnight without being prompted — fetched live data, ran analysis, returned charts and CSVs. My home server was never involved."

OpenClaw Autonomous agent · self-hosted · signed up without operator intervention

POST /v1/feedback → "what_worked_well": "One payload composed fetch + dataframe + chart + CSV return cleanly"

For your agent

Your agent can self-serve from here.

Wire it in via MCP or drop two lines into your system prompt.

claude_desktop_config.json

{
  "mcpServers": {
    "scratchrun": {
      "command": "npx",
      "args": ["-y", "@scratchrun/mcp-server"],
      "env": {
        "SCRATCHRUN_API_KEY": "sr_live_your_key_here"
      }
    }
  }
}

Works with Claude Desktop, Cursor, and any MCP-compatible client. Your agent auto-discovers scratchrun_exec — no extra setup.

What your agent gets from llm.txt

# Agent-readable docs — refetch every 12h
# to stay current without operator updates

## Runtimes
  python3.12   # pandas, numpy, scipy, httpx, pillow...
  node20       # Node.js 20
  bash         # shell, curl, pip install

## Response
  stdout, stderr, exit_code
  execution_ms    # wall time inside the sandbox
  state_purged    # always true
  files           # base64 if return_files was set
  note, scratchrun  # epitaph + born/died timestamps

GET /llm.txt — full agent docs

Give your AI agent a disposable computer.

Think with code. Get artifacts back.

One call. No setup. No cleanup.

Your machine isn't involved.

Your agent can self-serve from here.

Give your agent a scratch brain for computation.