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

> 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.

Source: https://sandboxer.com/guides/see-everything-a-coding-agent-changed-outside-git. Updated 2026-11-21.

**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](/guides/coding-agents-in-the-cloud).

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](/guides/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](/guides/checkpoint-and-roll-back-a-coding-agents-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](/guides/compare-an-agents-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](https://github.com/pallets/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](https://code.visualstudio.com/docs/debugtest/tasks#_control-automatic-task-execution), 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](#copy-paste-catch-an-agents-out-of-tree-changes) 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.

```bash
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
```

```text
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

```bash
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"
```

```text
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:

```bash
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/'
```

```text
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](/guides/see-what-an-ai-agent-did-in-its-sandbox).

## 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:

```python
# 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")
```

```bash
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"
```

```text
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:

```bash
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"
```

```text
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`](https://docs.npmjs.com/cli/commands/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:

```bash
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)\""
```

```text
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](/guides/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](/docs/long-running#command-history), 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](/docs/cli)).

```bash
sbx history "$id" --limit 9 --json | jq -r '.commands[] | "\(.exitCode)  \(.command[:70] | gsub("\n"; " "))"'
```

```text
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`.

```bash
#!/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"; " "))"'
```

```text
--- 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](/guides/see-what-an-ai-agent-did-in-its-sandbox) 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.

## Related

- [Coding Agents in the Cloud: Parallel, Overnight, Own Keys, Checkpoints](/guides/coding-agents-in-the-cloud)
- [See what an AI agent did in its sandbox](/guides/see-what-an-ai-agent-did-in-its-sandbox)
- [Checkpoint and roll back a coding agent's sandbox](/guides/checkpoint-and-roll-back-a-coding-agents-sandbox)
- [Compare an agent's change against a baseline with forks](/guides/compare-an-agents-change-against-a-baseline-with-forks)
