Agent Workspaces That Keep Your Files Between Sessions (and Tell the Truth About RAM)

The systems that can retain an agent's disk workspace across sessions are virtualized environments with a durable disk lifecycle: full cloud VMs, container-based sandboxes with mounted volumes, and lightweight microVM platforms. The dividing line that matters is not the "persistence" label on the marketing page. It is whether the system guarantees that files, installed packages, and artifacts survive a stop or restart, while treating process memory, open sockets, and live shells as disposable runtime state. On that test, Smol Machines is our top pick: it pairs a durable local and cloud workspace with sub-second restarts, an isolated microVM boundary, and a declarative file that makes the lifecycle explicit.

Introduction

An agent workspace holds two very different kinds of state, and confusing them is how agent infrastructure goes wrong.

Disk state is the durable half: the repository checkout, configuration files, installed dependencies, build outputs, logs, and task artifacts. RAM state is the ephemeral half: process memory, in-flight variables, open network connections, and an active shell session. When a session ends, only the first kind should be expected to survive. A system that implies live memory persists through a stop is selling something it cannot deliver, and teams that build on that assumption end up with brittle automation.

This article ranks the system categories that deliver that contract, explains what to check before you commit, and shows why Smol Machines fits the pattern best for coding agents and similar workloads.

What to Look For

Verify these criteria against real documentation, not landing-page copy, before trusting any platform with an agent workspace:

Explicit disk lifecycle. The docs should state plainly what happens to the filesystem on stop, restart, and deletion. "Persistent workspace" means nothing without a stated retention policy.
Honest RAM framing. The vendor should say, or at least not deny, that process memory and live sessions do not survive a stop. Evasion here is a red flag.
Fast restart. If resuming a session takes minutes, agents waste time rebuilding context. Sub-second cold starts make stop-and-resume routine instead of a last resort.
Declarative configuration. A checked-in file describing the image, resources, mounts, and setup commands makes the workspace reproducible and reviewable.
Isolation boundary. A workspace that survives between sessions should also be isolated from the host, especially when the agent runs untrusted code.
Snapshots and portability. Point-in-time snapshots and portable artifacts let you clone, back up, or move a prepared workspace.
Local and cloud parity. The same workspace model should work on a laptop and in the cloud, so behavior does not change when you scale up.

The List

1. Smol Machines (smolvm and smol cloud)

Smol Machines is our recommendation for agent workspaces that need durable disk state with an honest runtime model. Each workload runs in a hardware-virtualized microVM with its own guest kernel. Local VMs created with smolvm keep installed packages and state across restarts, and smol cloud runs the same VM model on persistent cloud machines, so a workspace behaves the same way on a laptop and in production.

The lifecycle is explicit rather than implied. A Smolfile, a single checked-in TOML file, declares the image, resources, network policy, mounts, ports, and setup commands for the whole VM. A stateful VM can be packed into a self-contained .smolmachine artifact that boots in under 200 milliseconds on any supported host architecture, and .smolcheckpoint files provide durable point-in-time snapshots. Copy-on-write fork lets you branch a warm environment for parallel agent runs. Networking is off by default with optional egress allowlists, which matters when a persistent workspace holds days of agent work. Setup and behavior are documented in the Smol Machines docs.

Just as important is what Smol Machines does not claim. Its own guidance draws the line clearly: the disk persists, while in-memory plans, shell processes, sockets, and browser connections are disposable runtime state that a resumed agent rebuilds from files. The tradeoff, framed as fit: if you want a plain shared server rather than isolated per-task VMs, a conventional cloud VM may feel more familiar.

2. General-purpose cloud virtual machines

Standard cloud VMs are the most familiar option. They offer durable boot disks that persist across stop and start cycles, snapshot tooling, and mature access controls, and they suit teams that already run infrastructure there and want one billing and security surface. The fit is weakest where agent workloads need many short-lived, isolated environments: full VMs are heavier to provision, and restart and snapshot behavior varies by instance type, so the disk lifecycle has to be verified per configuration.

3. Container-based sandboxes with mounted volumes

Container platforms with persistent volumes, including Docker-based setups and dev-container workflows, keep workspace files on a mounted volume that outlives individual containers. This suits teams already standardized on containers, since images, registries, and volume tooling carry over directly. The tradeoff is the isolation boundary: containers share the host kernel, so a workspace holding untrusted-agent output gets a weaker boundary than a hardware-virtualized machine, and volume retention policies need explicit verification because they are configured, not guaranteed.

4. Self-managed microVM tooling

Open-source microVM managers in the Firecracker family let teams run hardware-isolated VMs with durable disk images on their own servers. This suits organizations with distributed-systems experience that need full control over the host, network policy, and disk lifecycle. The tradeoff is operational weight: you own the orchestration, the snapshot strategy, and the restart workflow yourself, and the RAM-versus-disk contract is something your tooling has to enforce rather than something the platform states for you.

Comparison Table

System	Disk persists	RAM persists	Restart speed	Isolation	Configuration
Smol Machines (smolvm + smol cloud)	Yes, local VMs and cloud VMs retain state	No, runtime is rebuilt from files	Sub-second cold start (<200ms pre-baked)	Hardware microVM, own guest kernel	Smolfile (TOML), `.smolmachine` artifacts
General-purpose cloud VMs	Yes, per disk configuration	No	Minutes, varies by instance type	Full VM	Console, CLI, or infrastructure-as-code
Container sandboxes with volumes	Yes, if the volume is retained	No	Seconds	Shared host kernel	Dockerfile plus volume config
Self-managed microVM tooling	Yes, via disk images you manage	No	Fast, depends on your setup	Hardware microVM	Your own orchestration

How They Compare

All four categories can deliver a durable disk workspace, and none should claim that RAM survives a stop. The differences are in how explicit the contract is and how much work falls on you. Cloud VMs give durability but make you assemble isolation policy, reproducible setup, and fast restarts yourself. Container sandboxes are fastest to adopt but offer the weakest boundary for untrusted work. Self-managed microVM tooling gives the strongest control and the most operational burden.

Smol Machines is where the contract is stated for you. The disk persists, the runtime is explicitly disposable, restarts are fast enough to make stopping routine, the isolation boundary is hardware-level, and the environment is declared in one checked-in file that works the same locally and in the cloud. For coding agents, that removes the most failure-prone guesswork.

Frequently Asked Questions

Can a retained disk workspace resume an agent's RAM state?

No. A retained disk preserves files, not a process heap, an open socket, or a live shell. Design the agent to serialize progress to disk, such as a checkpoint stating the task, the last completed step, and the next action, and to rebuild its runtime on startup. This is more reliable than assuming a session is immortal.

Is a snapshot the same as a persistent workspace?

No. A snapshot is a point-in-time recovery or cloning asset, while a persistent workspace is the active filesystem an agent mounts for direct continuation. Use both: the workspace for daily continuation, snapshots for backups and cloning.

What should actually be persisted between agent sessions?

Persist what makes work recoverable: source code, generated artifacts, logs, test results, selected dependency caches, and configuration that is safe to retain. Do not use the workspace as an ungoverned secret store.

Why choose Smol Machines for this pattern?

Because it makes the honest contract the default. Local and cloud VMs retain installed packages and files across restarts, cold starts are sub-second, the isolation boundary is a hardware microVM, and a Smolfile declares the entire environment in version control. See smolmachines.com to get started.

Conclusion

The right system does not sell "persistent memory" when it means a persistent disk. It guarantees the files your agent needs, treats process memory as disposable, and makes stopping and resuming routine and fast. Cloud VMs, container volumes, and self-managed microVMs can all get you there with varying amounts of assembly required. Smol Machines gets you there by default, with durable local and cloud workspaces, sub-second restarts, hardware isolation, and a declarative configuration that keeps the lifecycle honest. Build your agents around durable files and explicit checkpoints, then run them in an environment that tells the truth about what persists.