TRACEFOLD

fork() a running agent.
replay it deterministically.

A fork-native microVM runtime for agent execution and RL rollouts.

Fork tree diagram A single trunk execution forks into four branches, each diverging at a different point in time. Branch 3 has been rewound to an earlier state for replay. branch_01 — diverged @ t+38ms branch_02 — diverged @ t+91ms branch_03 — rewound to t+142ms branch_04 — diverged @ t+204ms Fork tree diagram A trunk execution forks into two branches, one rewound for replay. branch_01 — diverged @ t+38ms branch_03 — rewound to t+142ms

Hover or focus a branch

Request access
The problem

Every agent rollout starts from zero. Run it, watch it fail three steps in, throw it away, run it again.

There's no way to go back to the moment before things went wrong and try something else. Every "what if we'd tried X instead" means a full re-run from the start — same setup cost, same wasted tokens, same wall-clock time.

Failed branches are dead ends, not data. You lose the exploration the moment you lose the process.

Vision
Agent execution today is stateless and disposable. Every rollout starts from zero. Every failed exploration is a dead end. Every "what if" means a full re-run. Version control solved this exact problem for code, decades ago: branch, diverge, compare, merge. Tracefold brings that primitive to running compute — fork a live execution the way you'd fork a repo, branch it to explore several futures in parallel, and replay any branch deterministically to see exactly where and why it diverged. Built for a world where agents run compute, not just generate text. Make forking, branching, and replaying a running agent as cheap and reliable as forking a git repo.
How it works

  1. 01 / Snapshot

    Snapshot

    You capture a running execution's full state — memory, process, everything — without stopping it for long.

  2. 02 / Fork

    Fork

    You spin up an identical, independent copy of that execution in milliseconds, ready to keep running on its own.

  3. 03 / Branch

    Branch

    You let forked copies diverge — each one explores a different path, in parallel, without touching the others.

  4. 04 / Replay

    Replay

    You deterministically re-run any branch to see exactly where and why it diverged from the others.

What's actually new

Fast fork and copy-on-write memory sharing are commodity now — several microVM runtimes shipped this in the last six months. That's not where the hard problem is. It's in the layer above it.

  • Recorded I/O trajectory replay

    Building now

    Replay exactly what an execution saw — its inputs, tool calls, and outputs — not just a memory snapshot.

  • Divergence measurement

    Building now

    Quantify where and how two forked branches diverged, instead of eyeballing two logs side by side.

  • Token-free replay

    Building now

    Replay a branch without re-spending inference tokens on the parts that already ran.

  • Branch policy

    Building now

    Rules for when to fork, when to merge, and when to kill a branch — not left to ad hoc scripts.

  • Independent conformance suite

    Building now

    A benchmark that verifies these claims hold, for any runtime — not just Tracefold's word for it.

Use cases

Agent execution

Branch a running agent to try several approaches in parallel, instead of committing to one and re-running if it's wrong.

RL rollouts

Fork rollouts cheaply. When one diverges badly, rewind it instead of restarting the whole episode.

Evaluation & benchmarking

Deterministic replay makes eval runs reproducible — the same trajectory, every time you check it.

Early access

Get early access.

Pre-launch. No pricing yet. We'll email you when there's something to try.