VMs (Pause & Fork)

Every Daytona sandbox can now run as a true microVM with full OS-level isolation. Pause freezes the entire machine state and resumes it in under a second. Fork clones a running VM into any number of identical copies from a single point in time.

Machine-level isolation

Sandboxes now run as microVMs rather than shared-kernel containers. Each sandbox has its own guest operating system, kernel, and virtualized hardware, so workloads are isolated at the machine level. This makes it safe to run untrusted or AI-generated code, and it provides the state boundary that pause and fork operate on.

Daytona provides default snapshots for creating Linux VM sandboxes:

1from daytona import Daytona, CreateSandboxFromSnapshotParams
2
3daytona = Daytona()
4
5# Create a Linux VM sandbox
6sandbox = daytona.create(
7    CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small")
8)

Daytona provides methods to create Linux VM sandboxes from a custom snapshot:

1from daytona import (
2    Daytona,
3    CreateSnapshotParams,
4    CreateSandboxFromSnapshotParams,
5    SandboxClass,
6)
7
8daytona = Daytona()
9
10# 1. Create a VM snapshot (linux-vm class)
11daytona.snapshot.create(
12    CreateSnapshotParams(
13        name="my-vm-snapshot",
14        image="ubuntu:22.04",
15        sandbox_class=SandboxClass.LINUX_VM,
16    )
17)
18
19# 2. Create a VM sandbox from the snapshot
20sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot="my-vm-snapshot"))

Pause and resume

Pause captures the full machine state of a running sandbox, including memory, processes, and open connections, and holds it. A paused sandbox consumes no compute. Resume restores the exact state in under a second, and processes continue from where they stopped.

This covers long-running agents that sit idle between steps. Instead of tearing down the environment and rebuilding it, you pause when work stalls and resume when the next event arrives, without losing in-memory state.

1from daytona import Daytona, CreateSandboxFromSnapshotParams
2
3daytona = Daytona()
4
5# Create a Linux VM sandbox
6sandbox = daytona.create(
7    CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small")
8)
9
10# Pause a sandbox
11sandbox.pause()
12
13# Resume a sandbox
14sandbox.start()

Fork

Fork clones a running VM into N identical copies. Each fork starts from the same machine state, including memory and running processes, and then diverges independently.

This enables branch-and-select workflows. An agent can reach a decision point, fork the VM into several branches, run a different path in each, and keep the branch that produces the best result. Every branch begins from identical state, so the comparison is deterministic.

1from daytona import Daytona, CreateSandboxFromSnapshotParams
2
3daytona = Daytona()
4
5# Create a Linux VM sandbox
6sandbox = daytona.create(
7    CreateSandboxFromSnapshotParams(snapshot="daytona-vm-small")
8)
9
10# Fork a sandbox
11forked = sandbox._experimental_fork()

Get started

VM sandboxes with pause & fork functionalities are available to all Daytona organizations. Read the documentation to get started.