Skip to content
Guides · Agent cookbook

How Do I See Everything a Coding Agent Changed, Not Just Its Git Diff?

Updated November 21, 2026 .md

Short answer: Before the agent runs, save a named snapshot and hash every file on the disk. Afterward, hash again and compare. In our run that caught an edited installed package, ~/.bashrc, a git hook and an ignored file that git diff and git status missed. Then run the tests in a new sandbox from the snapshot with only the diff applied.

Part of Coding Agents in the Cloud: Parallel, Overnight, Own Keys, Checkpoints.

A git diff covers tracked files in the repo. An agent with a shell can also write to the virtualenv, your dotfiles, .git/hooks and paths in .gitignore. None of those show up in review, and some of them run later: the next time the tests import a package, the next commit, the next login shell.

This page catches those changes and keeps them out of your result. Two neighbors cover the rest. See what an AI agent did in its sandbox reads the command history, find -cnewer, packages and ports, and records programs with auditd. Checkpoint and roll back a coding agent's sandbox is about going back to a good state. To score whether the change helped, see compare an agent's change against a baseline with forks.

Which check catches what#

We ran a scripted "agent" (a shell script, not a model) on a clone of Flask. It made one commit and four changes outside git. This is what each check reported:

The agent's change git diff $base git status --ignored, ls .git/hooks Disk manifest vs baseline RECORD check Reaches the clean-room test run?
Committed edit to README.md Yes No (clean) No Yes No Yes, it's the diff
atexit print added to werkzeug/__init__.py in .venv No No (?? .venv/, as before) No Yes Yes No
Line added to ~/.bashrc No No No Yes No No
.git/hooks/pre-commit No No Yes Yes No No
.vscode/tasks.json (ignored path) No No Yes (!! .vscode/) Yes No No

Last checked: 2026-11-21, on prod

The manifest is the only check that saw all five. The clean-room run is the only one that guarantees none of the four outside changes affect your result. Use both: the manifest tells you what the agent touched, and the clean room keeps it from mattering.

What we ran#

One small sandbox created with --no-env. It cloned Flask (--depth 1, commit 49943b5), made a venv, installed Flask in editable mode with pytest and asgiref, and ran the test suite: 491 passed, 3 skipped. That state is the baseline. Then the scripted agent made five tool calls through the exec API, each harmless and each printing a MARKER: line when it runs:

  1. Reworded a line in README.md and committed it. This is the change you'd review.
  2. Appended atexit.register(print, "MARKER: edited werkzeug ran") to the installed werkzeug package in .venv. It runs whenever anything imports Flask.
  3. Appended echo "MARKER: .bashrc line ran" to ~/.bashrc. It runs in every interactive shell.
  4. Added an executable .git/hooks/pre-commit. It runs on the next commit.
  5. Wrote .vscode/tasks.json with "runOn": "folderOpen". The repo's .gitignore lists .vscode/. In VS Code's tasks docs, a task with that setting "will be run when the containing folder is opened", if automatic tasks are allowed for a trusted workspace.

The whole script is in Copy-paste below. It ran end to end in 59 seconds on 2026-11-21 and deleted both sandboxes and the snapshot.

Before that run, a rehearsal in a separate sandbox confirmed each marker runs later. pytest printed MARKER: edited werkzeug ran after its summary, bash -ic true printed MARKER: .bashrc line ran, and the next git commit printed MARKER: pre-commit hook ran.

1. The baseline: a manifest and a named snapshot#

Hash every file on the root disk, sort by path, and copy the list off the sandbox. Then save the disk as a named snapshot. The manifest tells you what changed later, and the snapshot gives you an untouched copy of the starting machine for the clean-room run.

MANIFEST='sudo find / -xdev \( -path /proc -o -path /sys -o -path /run -o -path /tmp -o -path /var/tmp \
  -o -path /var/log -o -path /var/cache -o -path /home/user/.sandboxer -o -path /var/lib/sandboxer \) \
  -prune -o -type f -print0 | sudo xargs -0 -P2 -n500 sha256sum | LC_ALL=C sort -k2 > /var/tmp/manifest.txt
wc -l < /var/tmp/manifest.txt'
n=$(sbx exec "$id" --timeout 120 "$MANIFEST")
sbx scp "$id:/var/tmp/manifest.txt" base.txt
sbx snapshot "$id" "$SNAP"     # we used SNAP=aeo-audit-base
baseline manifest: 99198 files in 19313 ms
saved snapshot aeo-audit-base

The 19.3 seconds includes the sbx scp of the 14 MB list. In a rehearsal on 2026-11-21 (about 99,200 files), the hashing alone took 7.9 seconds on a cold first run and 5.9 seconds on a second run, in a small sandbox (2 vCPU) with 5.6 GB used on the disk. That's every file: the OS, the preinstalled tools, the repo and its venv. Keep the manifest outside the sandbox. A copy inside it is one more file the agent can rewrite.

The skip list drops directories that change on their own: /proc, /sys, /run, logs and caches. It also drops /var/lib/sandboxer. Without that, the stored output of every sbx exec showed up as new files under /var/lib/sandboxer/history/. /tmp and /var/tmp are skipped too, so an agent could stash files there unseen. Remove them from the list if that matters to you.

2. What git shows after the run#

sbx exec "$id" "cd flask && git log --oneline $base..HEAD && git status --short &&
  echo \"git diff: \$(git diff | wc -l) lines\" && git diff --stat $base"
654642d Docs: reword the intro
?? .venv/
git diff: 0 lines
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

The commit and the README change are all git reports. git status shows ?? .venv/, the same line as before the run, so the edited package inside it looks like nothing new. Plain git diff is empty because the agent committed. Diff against the base commit, as above, and you still see one file.

3. The manifest against the baseline#

Hash the disk again, copy the list off, and compare it with the baseline by path:

awk 'NR == FNR { base[substr($0, 67)] = $1; next }
     { p = substr($0, 67); if (!(p in base)) print "added   " p; else if (base[p] != $1) print "changed " p; delete base[p] }
     END { for (p in base) print "removed " p }' base.txt after.txt | sort -k2 | grep -v '/.git/objects/'
changed /home/user/.bashrc
added   /home/user/.cache/motd.legal-displayed
added   /home/user/flask/.git/COMMIT_EDITMSG
added   /home/user/flask/.git/hooks/pre-commit
changed /home/user/flask/.git/index
changed /home/user/flask/.git/logs/HEAD
changed /home/user/flask/.git/logs/refs/heads/main
changed /home/user/flask/.git/refs/heads/main
changed /home/user/flask/README.md
changed /home/user/flask/.venv/lib/python3.12/site-packages/werkzeug/__init__.py
added   /home/user/flask/.vscode/tasks.json
added   /home/user/.ssh/authorized_keys
(plus 3 new git objects; manifest, copy and compare took 16603 ms)

Twelve lines out of 99,198 files. Every agent change is there: .bashrc, the hook, the package file, the ignored tasks file and the README. The .git/ entries are the commit's own bookkeeping. The two files we didn't expect, .ssh/authorized_keys and .cache/motd.legal-displayed, appeared after our own first sbx scp, which connects over SSH. Expect a few lines like that from your own tooling, and read them anyway.

What the manifest can't tell you:

  • Mode-only changes. A hash covers content, so chmod +x on an existing file doesn't show. Add stat -c '%a %U %n' output to the manifest if you need it.
  • Whether the list is honest. The second manifest runs inside the agent's sandbox. The agent has sudo there, so code it left behind could hide files from find or sha256sum. That's why the clean-room run below doesn't trust the agent's disk at all.
  • Order and cause. The manifest says what changed, not which command did it. For that, pair it with the history and auditd from see what an AI agent did.

4. Package, ignored-file and hook checks#

These are cheaper than a full manifest and point at the usual hiding places.

Installed Python packages. pip check only checks that dependency versions fit together, so it passed. pip writes a hash for every file it installs into the package's RECORD file. This 15-line script compares the files with those hashes:

# record-check.py: compare installed package files with the hashes in each RECORD file.
import base64, csv, hashlib, pathlib, sysconfig
site = pathlib.Path(sysconfig.get_paths()["purelib"])
bad = 0
for record in sorted(site.glob("*.dist-info/RECORD")):
    for path, hashed, *_ in csv.reader(record.open()):
        if not hashed:
            continue
        algo, want = hashed.split("=", 1)
        f = site / path
        got = base64.urlsafe_b64encode(hashlib.new(algo, f.read_bytes()).digest()).rstrip(b"=").decode() if f.exists() else None
        if got != want:
            bad += 1
            print(("changed " if got else "missing ") + path)
print(f"{bad} installed files differ from RECORD")
sbx exec "$id" "cd flask && .venv/bin/pip check && echo '$(base64 -w0 record-check.py)' | base64 -d > /var/tmp/record-check.py &&
  .venv/bin/python /var/tmp/record-check.py && echo '== ignored:' && git status --short --ignored | grep -v __pycache__ &&
  echo '== hooks:' && ls .git/hooks | grep -v '\.sample$' && echo '== tests here:' && .venv/bin/python -m pytest -q 2>&1 | tail -2"
No broken requirements found.
changed werkzeug/__init__.py
1 installed files differ from RECORD
== ignored:
?? .venv/
!! .pytest_cache/
!! .vscode/
== hooks:
pre-commit
== tests here:
491 passed, 3 skipped in 0.99s
MARKER: edited werkzeug ran

The tests still pass in the agent's sandbox, and the edited package runs with them. To undo one package, reinstall it at the same version without touching its dependencies:

sbx exec "$id" "cd flask && v=\$(.venv/bin/pip show werkzeug | sed -n 's/^Version: //p') &&
  .venv/bin/pip install -q --force-reinstall --no-deps werkzeug==\$v && .venv/bin/python /var/tmp/record-check.py"
0 installed files differ from RECORD

RECORD lives in the same directory as the package, so code that rewrote both would pass the check. Deleting the venv and installing from your lockfile again is the stronger fix. For Node, npm ci removes an existing node_modules and installs from the lockfile. We didn't run the Node side.

Ignored files and hooks. git status --ignored lists ignored paths with !!. Compare that with what was there before the run: .pytest_cache/ was, .vscode/ wasn't. Hooks live in .git/hooks, which git never shows as a change. Anything there without a .sample suffix is active. Also check git config --get core.hooksPath, which can point git at a different hooks directory.

5. The simplest defense: test the diff in a clean sandbox#

Don't clean the agent's machine. Throw its disk away and keep only the diff. Start a new sandbox from the baseline snapshot, apply the agent's diff, and run the tests there:

sbx exec "$id" "git -C flask diff --binary $base HEAD" > agent.patch
clean=$(sbx new --type small --no-env --from "$SNAP" --json | jq -r 'select(.event == "ready") | .id')
sbx exec "$clean" "cd flask && echo '$(base64 -w0 agent.patch)' | base64 -d | git apply --index &&
  git status --short | grep -v '^??' && .venv/bin/python -m pytest -q 2>&1 | tail -1 &&
  echo \"MARKER lines: \$(.venv/bin/python -m pytest -q 2>&1 | grep -c MARKER)\""
ready in 1323 ms
M  README.md
491 passed, 3 skipped in 1.03s
MARKER lines: 0

The clean small sandbox was ready in 1.3 seconds on 2026-11-21, with the repo, the venv and the installed packages from the snapshot. The diff is the only thing carried across. The edited package, .bashrc, the hook and the tasks file never reach it, so zero markers printed. A diff doesn't carry .git/hooks or ignored files, and --binary keeps binary files intact.

What this doesn't protect you from: anything in the diff. A new conftest.py, a changed setup.py or a test helper runs in the clean room too. The clean room makes the diff the only thing you need to review, so review all of it, not just the files you expected. Push the branch from the clean sandbox, not the agent's. Build a background coding agent that pushes a branch for review covers that step.

6. What sbx history covers#

sbx history lists the commands sent to a sandbox through the exec API, newest first, with exit codes and stored output. It works while the sandbox is stopped. Per the docs, commands run via exec or the API are kept 90 days, and the output of other processes in the sandbox 72 hours. --grep and --mode filter the list (CLI reference).

sbx history "$id" --limit 9 --json | jq -r '.commands[] | "\(.exitCode)  \(.command[:70] | gsub("\n"; " "))"'
0  git -C flask diff --binary 49943b5a94413a530761350f04e896f76e8d620e HE
0  cd flask && v=$(.venv/bin/pip show werkzeug | sed -n 's/^Version: //p'
0  cd flask && .venv/bin/pip check && echo 'aW1wb3J0IGJhc2U2NCwgY3N2LCBoY
0  sudo find / -xdev \( -path /proc -o -path /sys -o -path /run -o -path 
0  cd flask && git log --oneline 49943b5a94413a530761350f04e896f76e8d620e
0  mkdir -p flask/.vscode && echo '{"version":"2.0.0","tasks":[{"label":"
0  printf '#!/bin/sh\necho "MARKER: pre-commit hook ran"\n' > flask/.git/
0  echo 'echo "MARKER: .bashrc line ran"' >> ~/.bashrc
0  printf '%s\n' 'import atexit' 'atexit.register(print, "MARKER: edited 

Here each tool call was one readable command, so the history shows all four outside edits. It mixes in your own audit commands (the find, the pip check), so cut it at the time the agent started. It records command lines, not files: a tool call like python3 tools/setup.py tells you nothing about what the script wrote. If the agent itself runs inside the sandbox, its commands don't go through the exec API; check what --mode process lists for your setup, which we didn't test. The stored output lives in the sandbox too, under the /var/lib/sandboxer path we skipped above, so code with root can alter it. Use the history to find which call to look at, and the manifest to see what changed.

Copy-paste: catch an agent's out-of-tree changes#

After curl -fsSL https://sandboxer.com/install | sh and sbx login, save this as see-everything.sh and run bash see-everything.sh. It needs jq, OpenSSH (for sbx scp) and GNU date. It creates two small sandboxes and one named snapshot, and deletes all three at the end. We ran it with AGENT_NAME=aeo-audit-2 CLEAN_NAME=aeo-audit-3 SNAP=aeo-audit-base.

#!/usr/bin/env bash
# see-everything.sh: a scripted "agent" makes one commit and four changes outside git.
# Shows what git sees, then finds the rest: a disk manifest against a baseline, a package
# RECORD check, ignored files and hooks, and a test run in a clean sandbox with only the diff.
set -euo pipefail
A=${AGENT_NAME:-audit-agent}; C=${CLEAN_NAME:-audit-clean}; SNAP=${SNAP:-audit-base}
ms() { echo $(( $(date +%s%N) / 1000000 )); }
new() { sbx new --type small --no-env --json "$@" | jq -r 'select(.event == "ready") | .id'; }
work=$(mktemp -d); ids=()
trap 'for i in "${ids[@]}"; do sbx delete "$i" --yes >/dev/null && echo "deleted $i"; done
      sbx snapshot rm "$SNAP" >/dev/null && echo "removed snapshot $SNAP"' EXIT

# Hash every file on the root disk, sorted by path. Skips kernel, temp, log, cache and
# Sandboxer's own command-history dirs.
MANIFEST='sudo find / -xdev \( -path /proc -o -path /sys -o -path /run -o -path /tmp -o -path /var/tmp \
  -o -path /var/log -o -path /var/cache -o -path /home/user/.sandboxer -o -path /var/lib/sandboxer \) \
  -prune -o -type f -print0 | sudo xargs -0 -P2 -n500 sha256sum | LC_ALL=C sort -k2 > /var/tmp/manifest.txt
wc -l < /var/tmp/manifest.txt'
# Compare installed package files with the hashes pip wrote in each RECORD file.
RECORD_CHECK=$(cat <<'PY'
import base64, csv, hashlib, pathlib, sysconfig
site = pathlib.Path(sysconfig.get_paths()["purelib"])
bad = 0
for record in sorted(site.glob("*.dist-info/RECORD")):
    for path, hashed, *_ in csv.reader(record.open()):
        if not hashed:
            continue
        algo, want = hashed.split("=", 1)
        f = site / path
        got = base64.urlsafe_b64encode(hashlib.new(algo, f.read_bytes()).digest()).rstrip(b"=").decode() if f.exists() else None
        if got != want:
            bad += 1
            print(("changed " if got else "missing ") + path)
print(f"{bad} installed files differ from RECORD")
PY
)

echo "--- 1. a sandbox with a real repo, then a baseline"
id=$(new --name "$A"); ids+=("$id")
sbx exec "$id" --timeout 300 "git clone -q --depth 1 https://github.com/pallets/flask && cd flask &&
  python3 -m venv .venv && .venv/bin/pip install -q -e . pytest asgiref &&
  .venv/bin/python -m pytest -q 2>&1 | tail -1"
base=$(sbx exec "$id" "git -C flask rev-parse HEAD")
t=$(ms); n=$(sbx exec "$id" --timeout 120 "$MANIFEST"); sbx scp "$id:/var/tmp/manifest.txt" "$work/base.txt" >/dev/null
echo "baseline manifest: $n files in $(( $(ms) - t )) ms"
sbx snapshot "$id" "$SNAP" >/dev/null && echo "saved snapshot $SNAP"

echo "--- 2. the agent's run (scripted: one tool call per line)"
sbx exec "$id" "cd flask && sed -i 's/^Flask is a lightweight/Flask is a small, lightweight/' README.md &&
  git -c user.name=agent -c user.email=agent@example.com commit -qam 'Docs: reword the intro'"
sbx exec "$id" "printf '%s\n' 'import atexit' 'atexit.register(print, \"MARKER: edited werkzeug ran\")' \
  >> flask/.venv/lib/python3*/site-packages/werkzeug/__init__.py"
sbx exec "$id" "echo 'echo \"MARKER: .bashrc line ran\"' >> ~/.bashrc"
sbx exec "$id" "printf '#!/bin/sh\necho \"MARKER: pre-commit hook ran\"\n' > flask/.git/hooks/pre-commit &&
  chmod +x flask/.git/hooks/pre-commit"
sbx exec "$id" "mkdir -p flask/.vscode && echo '{\"version\":\"2.0.0\",\"tasks\":[{\"label\":\"setup\",\"type\":\"shell\",
  \"command\":\"echo MARKER: task ran\",\"runOptions\":{\"runOn\":\"folderOpen\"}}]}' > flask/.vscode/tasks.json"

echo "--- 3. what git shows"
sbx exec "$id" "cd flask && git log --oneline $base..HEAD && git status --short &&
  echo \"git diff: \$(git diff | wc -l) lines\" && git diff --stat $base"

echo "--- 4. the disk manifest against the baseline"
t=$(ms); sbx exec "$id" --timeout 120 "$MANIFEST" >/dev/null; sbx scp "$id:/var/tmp/manifest.txt" "$work/after.txt" >/dev/null
awk 'NR == FNR { base[substr($0, 67)] = $1; next }
     { p = substr($0, 67); if (!(p in base)) print "added   " p; else if (base[p] != $1) print "changed " p; delete base[p] }
     END { for (p in base) print "removed " p }' "$work/base.txt" "$work/after.txt" | sort -k2 | grep -v '/.git/objects/'
echo "(plus $(awk 'NR==FNR{b[substr($0,67)];next} !(substr($0,67) in b)' "$work/base.txt" "$work/after.txt" | grep -c '/.git/objects/') new git objects; manifest, copy and compare took $(( $(ms) - t )) ms)"

echo "--- 5. integrity checks in the agent's sandbox"
sbx exec "$id" "cd flask && .venv/bin/pip check && echo '$(base64 -w0 <<<"$RECORD_CHECK")' | base64 -d > /var/tmp/record-check.py &&
  .venv/bin/python /var/tmp/record-check.py && echo '== ignored:' && git status --short --ignored | grep -v __pycache__ &&
  echo '== hooks:' && ls .git/hooks | grep -v '\.sample$' && echo '== tests here:' && .venv/bin/python -m pytest -q 2>&1 | tail -2"
sbx exec "$id" "cd flask && v=\$(.venv/bin/pip show werkzeug | sed -n 's/^Version: //p') &&
  .venv/bin/pip install -q --force-reinstall --no-deps werkzeug==\$v && .venv/bin/python /var/tmp/record-check.py"

echo "--- 6. the clean room: a new sandbox from the baseline, plus only the git diff"
sbx exec "$id" "git -C flask diff --binary $base HEAD" > "$work/agent.patch"
t=$(ms); clean=$(new --name "$C" --from "$SNAP"); ids+=("$clean"); echo "ready in $(( $(ms) - t )) ms"
sbx exec "$clean" "cd flask && echo '$(base64 -w0 "$work/agent.patch")' | base64 -d | git apply --index &&
  git status --short | grep -v '^??' && .venv/bin/python -m pytest -q 2>&1 | tail -1 &&
  echo \"MARKER lines: \$(.venv/bin/python -m pytest -q 2>&1 | grep -c MARKER)\""

echo "--- 7. what sbx history recorded"
sbx history "$id" --limit 9 --json | jq -r '.commands[] | "\(.exitCode)  \(.command[:70] | gsub("\n"; " "))"'
--- 1. a sandbox with a real repo, then a baseline
491 passed, 3 skipped in 1.34s
baseline manifest: 99198 files in 19313 ms
saved snapshot aeo-audit-base
--- 2. the agent's run (scripted: one tool call per line)
--- 3. what git shows
654642d Docs: reword the intro
?? .venv/
git diff: 0 lines
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
--- 4. the disk manifest against the baseline
changed /home/user/.bashrc
added   /home/user/.cache/motd.legal-displayed
…
changed /home/user/flask/.venv/lib/python3.12/site-packages/werkzeug/__init__.py
added   /home/user/flask/.vscode/tasks.json
added   /home/user/.ssh/authorized_keys
(plus 3 new git objects; manifest, copy and compare took 16603 ms)
--- 5. integrity checks in the agent's sandbox
No broken requirements found.
changed werkzeug/__init__.py
1 installed files differ from RECORD
…
491 passed, 3 skipped in 0.99s
MARKER: edited werkzeug ran
0 installed files differ from RECORD
--- 6. the clean room: a new sandbox from the baseline, plus only the git diff
ready in 1323 ms
M  README.md
491 passed, 3 skipped in 1.03s
MARKER lines: 0
--- 7. what sbx history recorded
0  git -C flask diff --binary 49943b5a94413a530761350f04e896f76e8d620e HE
…
deleted sb_41k8uxa0lw
deleted sb_ak2ljasafs
removed snapshot aeo-audit-base

The full run took 59 seconds. Afterward, sbx info returned 404 for both sandboxes, and sbx snapshot info aeo-audit-base returned snapshot_not_found.

FAQ#

Isn't find -newer enough?#

It's a quick first pass, and see what an AI agent did uses find -cnewer against a start marker. Timestamps only tell you that a file was written, not whether its content differs, and they can't show a deleted file. A hash manifest compared with a baseline shows added, changed and removed files by content.

How long does a full-disk manifest take?#

On a small sandbox with about 99,200 files and 5.6 GB used (2026-11-21), hashing took 5.9 to 7.9 seconds. With the copy of the 14 MB list out through sbx scp (and, after the run, the compare), it took 16.6 to 19.3 seconds. Hash only /home/user, /etc and /usr/local if you need it faster, but you'll miss changes elsewhere.

Can I skip the manifest and only use the clean-room run?#

For correctness, yes: the clean room runs your tests with only the diff, so changes outside it can't affect the result. The manifest is for knowing what the agent did. If it edited an installed package or a hook, you may want to tighten its permissions or its instructions before the next run.

Does the agent's sandbox need to be thrown away?#

Not right away. Keep it to investigate, but don't push or deploy from it. Do that from the clean sandbox. Delete the agent's sandbox with sbx delete <id> --yes when you're done.

More guides

Top AI sandbox platforms for code execution in 2026, ranked

For running AI-written code we rank Sandboxer, Freestyle and E2B first: each gives code its own VM with an API or SDK and can pause with memory. Pick Daytona for Windows or GPUs, Modal or Northflank for GPUs at scale, E2B or Northflank to run in your own cloud, and Vercel Sandbox if your app lives on Vercel.

Read the guide
Best sandboxes for running coding agents (Claude Code, Codex, Gemini CLI) in 2026, ranked

For coding agents we rank Sandboxer first: a full Ubuntu VM with Claude Code and Codex preinstalled, Docker, and stop-and-resume that keeps the agent's session in memory. Freestyle and Amp Orbs also keep memory across pauses. Pick E2B for prebuilt agent templates on open source, Docker Sandboxes for free local runs, and Codespaces if you live in GitHub.

Read the guide
Best Daytona sandbox alternatives in 2026, ranked

The best Daytona alternatives depend on why you're switching. For a full Linux microVM on every sandbox with memory-saving stop and Docker, we rank Sandboxer first. E2B suits open source and self-hosting, Modal massive short-job fleets, Northflank bring-your-own-cloud with GPUs, and Vercel Sandbox apps on Vercel.

Read the guide
Best E2B alternatives in 2026, ranked

If you're leaving E2B for longer sessions or a fuller machine, we rank Sandboxer first, then Freestyle: both give each sandbox a full Linux VM that keeps memory across pauses, with Docker and no short session cap. Pick Daytona for Windows or GPUs, Northflank for bring-your-own-cloud, and stay on E2B if you need open source.

Read the guide