Browse the 0.2.x roadmap
Back to roadmap overview
01 · System design

A durable checkpoint graph over a bounded execution pool.

The graph is the product-level source of history; execution attempts are disposable projections. LayerStack preserves workspace identity while OCI/Linux and WASI provide different ways to run it.

Status
Target design
Scope
0.2.x architecture
Primary decision
Graph over sessions
Portability
OCI/Linux + WASI

Architecture decision

Persist nodes. Rent execution.

A SandboxNode is an immutable checkpoint reference plus logical state and provenance. It does not permanently own a container, mount, process, or worker. The scheduler activates only the frontier required by current work.

Immutable roots
A selectable node never changes after sealing.
Private writes
Every active attempt owns its writable delta.
Bounded residency
Live sandboxes are capped independently of graph size.
Explicit integration
Only OCC merge or promotion advances canonical state.

Reference architecture

Control, state, and execution remain separate.

The orchestration plane owns graph semantics. The state plane owns durable identity. Executors consume leases and return sealed results; they never become the source of checkpoint truth.

Control, state, and execution remain separate.

Workload controllers

Multiagent development
RL coordinator
MCTS controller

Orchestration plane

SandboxGroup service
Search / rollout state
Placement scheduler
Evaluator / verifier

Durable state plane

Logical manifests
Content-addressed storage
OCC · leases · journal
Trajectories · evidence

Bounded worker pool

OCI/Linux executor
WASI executor

Sealed result

Checkpoint · logs · patch · evaluation · provenance

Checkpoint graph

History can grow without keeping every branch alive.

Nodes share immutable roots and content identities. Activation allocates an execution attempt with a private delta; suspension seals that delta and releases the runtime slot.

root / N0

durable

candidate A

sealed

candidate B

active attempt

candidate C

sealed

B / child 1

active attempt

B / child 2

prunable

One root fans out to coding, rollout, or search candidates. Only selected nodes occupy the worker pool.

Fork accounting

Logical child
O(1)
Parent RootId + new node metadata
Hot local lower
0 payload bytes
Lease an existing immutable native root
Writable state
Changes only
Private upper/delta grows with actual writes
Cold worker
Hydration cost
Materialize once, then share locally

Durable delta storage

Content-defined chunking makes the checkpoint graph space-aware.

Stable content identities sit beneath logical tree manifests and immutable B/L/S deltas. The capture path can reuse unchanged content and pack metadata without moving CAS reconstruction into commands, PTY, or stdin.

Explore content-defined chunking

Lifecycle protocol

Checkpoint publication is an explicit transaction.

The critical path is expressed as a recoverable state machine so a crash can resume or abort without inventing a partially published node.

ControllerState planeSchedulerExecutorEvaluator
01Fork

Create child NodeId referencing an immutable parent RootId.

02Lease

Pin root and reserve one bounded execution slot.

03Activate

Build the backend view and allocate a private writable delta.

04Execute

Run commands or a rollout; stream evidence to attempt storage.

05Quiesce

Stop admissions, drain command/PTY work, and freeze the delta boundary.

06Seal

Publish manifest, logical state, provenance, and attempt result atomically.

07Evaluate

Run versioned tests or reward logic against the sealed root.

08Resolve

Promote, merge, backpropagate, retain, or prune idempotently.

State ownership

Each fact has exactly one durability owner.

01

Global durable

Root manifests, CAS objects, node graph, logical agent state, policies, evaluator versions, trajectories, audit records

State plane

02

Worker durable cache

Hydrated immutable roots, verified native extents, reusable image/runtime materialization

Worker cache manager

03

Attempt ephemeral

Mount namespace, private upperdir, workdir, PID/cgroup state, live PTY buffers

Executor lease

OCI/Linux projection

Mount over LayerStack materialization—not over user host volumes.

A worker hydrates or reuses an immutable native lower root, then composes a private writable view inside the sandbox mount namespace. The target image supplies no helper binary and never owns durable workspace truth.

Mount over LayerStack materialization—not over user host volumes.

Immutable lower root

Worker-local, verified, shared read-only

Private upper + work

Attempt-local writable delta

Overlay workspace

Mounted inside executor namespace

Command / PTY

Ordinary native file access