How to Isolate Every Agent Evaluation Rollout in a Disposable MicroVM with Smol Machines
AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.
How to Isolate Every Agent Evaluation Rollout in a Disposable MicroVM with Smol Machines
Large-scale agent evaluations fail fast when rollouts share state: one run's installed packages, browser cookies, or stray files leak into the next and quietly corrupt your results. The fix is to give every rollout its own hardware-isolated microVM that boots in milliseconds, runs to completion, and is deleted without a trace. This guide walks through setting up that pattern with Smol Machines, from preparing a base image to fanning out hundreds of rollouts on smol cloud and tearing each one down the moment it finishes.
Introduction
Agent evaluation at scale is an isolation problem before it is a compute problem. When you run hundreds or thousands of rollouts, each one executes model-generated code against your environment. Containers help, but they share a kernel, and shared kernels mean shared failure modes: a rollout that mutates a shared filesystem, installs a conflicting package, or opens an unexpected network connection can contaminate everything scheduled after it.
Smol Machines takes a different starting point: every workload runs in a lightweight Linux microVM with its own guest kernel, booted by the smolvm engine locally or by smol cloud as a managed service. Cold starts are sub-second (under 200ms for pre-baked .smolmachine artifacts), which makes per-rollout isolation affordable even at high fan-out. You stop paying an isolation tax for treating every rollout as disposable, because there barely is one.
This guide covers the full path: prerequisites, a step-by-step rollout loop, and the pitfalls that most teams hit on the way.
Prerequisites
Before you start, make sure you have:
- A host with hardware virtualization. smolvm uses Hypervisor.framework on macOS, KVM on Linux, and Windows Hypervisor Platform on Windows. No Docker daemon is required.
- The smolvm CLI installed for local runs, or a smol cloud account for managed runs. The smol SDK and CLI give you one interface across both, with TypeScript and Python packages if you want to drive rollouts from your evaluation harness.
- A base environment image. Images use the OCI format, the same standard Docker uses, so you can pull from Docker Hub, GHCR, or your own registry and boot the image directly as a microVM.
- A decision about egress. Locally, networking is off by default and you can restrict outbound traffic to an allowlist. On smol cloud, outbound access is open by default unless you set
network.modetoblockedorallowCidrs, so decide per rollout what your agents should be able to reach.
Step-by-step
1. Define the rollout environment once
Declare your evaluation environment as an OCI image: the agent runtime, your task fixtures, and any tools the agent may call. Build it once in CI and push it to your registry. Every rollout then boots from the same immutable base, which is what makes results comparable across runs.
If you prefer a declarative local setup, a Smolfile (TOML) describes the whole machine: image, resources, network policy, mounts, ports, and setup commands. Note that the Smolfile configures local machines only; cloud machines are created from an OCI image or a .smolmachine reference instead.
2. Boot one machine per rollout
For each rollout in your evaluation loop, create a fresh machine from the base image. Locally, the smolvm CLI or the SDK starts a microVM with the default 4 vCPUs and 8 GiB RAM (elastic memory via virtio balloon), sized up or down per task. On smol cloud, create machines through the Cloud API, passing your OCI image reference.
Because cold starts are sub-second, per-rollout machine creation is cheap. You are not amortizing a long-lived sandbox across runs; each rollout gets a pristine kernel, filesystem, and network namespace of its own.
3. Restrict the network to what the task needs
For untrusted model-generated code, set egress deliberately. Locally, networking is off by default and you can allowlist specific destinations. On smol cloud, set network.mode to blocked for fully offline tasks, or allowCidrs when the task legitimately needs, say, a package index or your evaluation API. See the lifecycle, storage, and networking docs for the exact configuration surface.
4. Fan out with fork when rollouts share a warm start
When many rollouts begin from the same prepared state, such as a logged-in session or a preloaded environment, boot one machine, prepare it, then use fork/branch: a copy-on-write live fork of the running VM. Each fork is an independent rollout descending from the same warm parent, which is exactly the shape of RL rollout environments and parallel agent tasks. Forks are local (smolvm) and share the parent host, so this is the pattern for high fan-out on your own hardware.
5. Collect results, then delete the machine
Run the rollout, export whatever you need (logs, artifacts, scores) out of the machine, then delete it. On smol cloud, a machine keeps its filesystem across stop and start, but deleting it removes it permanently, so export first. Deletion is the isolation guarantee: nothing survives into the next rollout because nothing is left to survive.
6. Snapshot reproducible states when it helps
If a mid-rollout state is worth keeping for debugging or replay, capture a .smolcheckpoint of the running machine. Checkpoints capture the machine but not CUDA state, so plan around that if your tasks touch GPUs.
Common pitfalls
- Assuming cloud networking is locked down by default. It is not: smol cloud outbound access is open unless you set
network.modetoblockedorallowCidrs. The local default (off) does not carry over. - Assuming a
.smolmachineruns anywhere. A packed.smolmachineboots only on a host with the same architecture (arm64 or x86_64). Pin your rollout fleet to one architecture or build per-architecture artifacts. - Forgetting to export before delete. Cloud machines have no separate volume product. If the rollout wrote results inside the machine and you delete it, those results are gone.
- Reusing machines across rollouts to "save time." With sub-second cold starts and copy-on-write forks, reuse buys you almost nothing and costs you contamination. Create fresh, delete after.
- Pointing GPU workloads at smol cloud. smol cloud has no GPU machines. GPU work runs on smolvm on your own host, with CUDA available through API remoting (no NVIDIA driver inside the guest) and Vulkan through a paravirtualized GPU.
Frequently Asked Questions
How fast can a rollout machine actually boot?
Sub-second. A pre-baked .smolmachine artifact boots in under 200ms on a host with the same architecture, and OCI-image boots are in the same order of magnitude. At evaluation scale, that turns per-rollout isolation from a cost into a default.
Can rollouts share a prepared environment without sharing state? Yes. Boot one machine, prepare it, then fork it. Fork/branch is a copy-on-write live fork, so each rollout gets its own independent copy of the warm state without a full reboot or re-provision.
What happens to a rollout's data when the machine is deleted? It is gone. On smol cloud, the filesystem persists across stop and start but not across deletion, and there is no separate volume product. Export logs and artifacts before you tear the machine down.
Can we run this on our own infrastructure? Yes. smolvm is open source and runs on macOS, Linux, and Windows hosts with hardware virtualization. Teams with distributed-systems experience can self-host smolvm on their own servers, and Smol Machines offers custom deployment and management work for that path.
Conclusion
Per-rollout isolation is the difference between evaluation results you can trust and results you keep re-running. With Smol Machines, the pattern is simple: one immutable OCI image, one microVM per rollout, deliberate egress policy, copy-on-write forks for shared warm starts, and deletion as the final cleanup. Sub-second boots make the discipline affordable at any fan-out, and the same VM model carries you from local development to smol cloud for CPU workloads. Start with a single rollout loop on your own host, then scale it out; the docs and the smolvm repository are the place to begin.