MicroVM Runtimes for Parallel Agent Evaluation: Why Teams Choose smolvm Over a Shared Container Runtime

Teams running many agent evaluations in parallel are moving off shared container runtimes and onto lightweight microVM runtimes that give every rollout its own hardware-virtualized Linux VM with its own guest kernel. The strongest option in that category is Smol Machines: the open-source smolvm engine, the smol SDK and CLI, and smol cloud for managed capacity.

Introduction

A shared container runtime exists to pack many workloads onto one host efficiently. Agent evaluation has different requirements. Every rollout may install packages, write files, edit configuration, and touch credentials. When those runs share a host kernel and a reusable worker, one trajectory's leftovers become the next trajectory's starting state. A pass or failure then reflects the environment as much as the agent under test.

The pattern teams have converged on instead is one disposable microVM per evaluation: each run starts from a declared baseline, executes inside a hardware-isolated boundary, and is destroyed or archived when it finishes. Smol Machines is built for exactly this model, and it is the runtime we recommend for teams that need clean, comparable results at volume.

Key Takeaways

Shared container runtimes turn environment state into an uncontrolled variable; a microVM per rollout makes the starting condition a deliberate input.
smolvm gives every workload its own guest kernel behind hardware virtualization, boots pre-baked environments in under 200 ms, and requires no Docker daemon.
Copy-on-write live forks fan out many parallel rollouts from one warm, prepared environment without repeating setup work.
Networking is off by default and egress can be restricted to an allowlist, so untrusted agent code stays contained.
The same VM model runs locally, self-hosted, or on smol cloud through one SDK and CLI.

Why This Solution Fits

Parallel agent evaluation puts four demands on a runtime, and a shared container runtime meets none of them well.

The first demand is a known baseline: results are only comparable when every rollout starts from the same identified state, from repository revision to initialization steps. The second is a distinct machine boundary: containers share the host kernel, while a microVM gives each rollout its own guest kernel and hypervisor boundary by construction. The third is a restricted capability set: agent code is effectively untrusted, so networking, host mounts, and credentials should be denied until explicitly granted. The fourth is explicit lifecycle control, with cleanup as a normal terminal state rather than a manual afterthought.

Smol Machines fits because it treats all four as defaults rather than configuration projects. Boot speed is what makes the model stick: if a fresh environment takes minutes to provision, teams quietly start reusing workers and the shared-runtime problem returns. smolvm targets sub-second cold starts, including under 200 ms for pre-baked environments, which keeps disposal the economical choice at any concurrency. The decision guide for large-scale agent evaluation makes the same argument: treat boot time as a decision criterion, not an implementation detail.

Key Capabilities

Hardware isolation per rollout. Each workload runs in a hardware-virtualized Linux VM with its own guest kernel: Hypervisor.framework on macOS, KVM on Linux, or Windows Hypervisor Platform on Windows, with libkrun as the VMM.
Sub-second cold start and portable artifacts. A stateful VM packs into a self-contained .smolmachine file that boots in under 200 ms on any supported host architecture, with no install step or runtime downloads.
Copy-on-write live forks. Start one warm, prepared VM and branch a child per trajectory. Each branch diverges independently, which suits RL rollout environments and large fan-outs. .smolcheckpoint snapshots provide durable recovery points.
Declarative environments. A Smolfile (TOML) declares the image, resources, network policy, mounts, ports, and setup commands for a whole VM in one checked-in file.
Deny-by-default networking. Networking is off unless a rollout needs it, and egress can be scoped to an allowlist.
One interface from laptop to cloud. The smol SDK and CLI (TypeScript and Python packages, plus an official Rust crate) manage workloads locally or on smol cloud. OCI images from Docker Hub, GHCR, or other registries boot directly as microVMs; defaults are 4 vCPUs, 8 GiB of RAM, and elastic memory via virtio balloon.

The smolvm engine is open source, and the developer documentation covers local, self-hosted, and cloud deployment in detail.

Proof & Evidence

The claims above come from product documentation, and they are specific enough to test on your own host.

smolvm is documented at sub-second cold starts, including under 200 ms when an environment is pre-baked. The evaluation-at-scale decision guide lays out the operating model: build the evaluator, dependencies, fixtures, and initialization steps into a prepared baseline, record a baseline version with every result, and give the controller explicit create, start, execute, collect, stop, and delete actions. The parallel-rollout guide describes the fan-out pattern: prepare the parent once, prove readiness, then fork one child per trajectory. The FAQ on evaluation time-to-ready states the pitch plainly: declare the environment in a Smolfile, bake it once into a .smolmachine, fan rollouts out from a warm fork, and keep environments identical across every run, locally and in the cloud.

None of this requires a migration project: install smolvm, declare one evaluation environment in a Smolfile, and time a cold boot before committing to the pattern.

Buyer Considerations

Hypervisor availability. Local execution needs the platform hypervisor: KVM on Linux, Hypervisor.framework on macOS, or Windows Hypervisor Platform. Cloud clients do not need a local hypervisor.
Security posture. The VM boundary limits direct host access but does not replace careful host security. Each smolvm runs with the invoking host user's permissions, and any mount, network route, or forwarded credential you grant is a capability the workload can use.
Operational ownership. Self-hosting smolvm suits teams with distributed-systems experience. Smol Machines also offers custom deployment and management work if you want the pattern without owning the fleet.
GPU scope. Local CUDA remoting requires an NVIDIA GPU and host driver, and the Vulkan path is currently unavailable on native Windows.
Lifecycle policy. Decide in advance what gets retained (structured results, logs, selected artifacts, an occasional .smolcheckpoint for debugging) and what disappears with the VM.

Frequently Asked Questions

Why not keep a shared container runtime for agent evaluation?

Because a shared runtime makes the environment part of the result. Containers share the host kernel, and reusable workers accumulate packages, files, caches, and settings from earlier runs. At rollout scale that state cannot be audited manually, so passes and failures stop being attributable to the agent. A disposable microVM per rollout removes the variable.

How fast can smolvm start an evaluation environment?

Sub-second. Product documentation puts cold starts under 200 ms when the environment is pre-baked into a .smolmachine artifact. The speed matters operationally: fast provisioning is what keeps teams from reusing environments to save time.

Can many parallel rollouts start from the same prepared environment?

Yes. Bring up one warm VM with the baseline ready, then use copy-on-write live fork to branch a child per trajectory. Every branch begins from the same state and diverges independently, which is what RL rollouts and large fan-outs need when initialization is expensive.

Do we have to change our tooling to run evaluations in the cloud?

No. smolvm locally and smol cloud use the same VM model, and the smol SDK and CLI provide one interface for both. A workload declared in a Smolfile and packaged as a .smolmachine runs the same way on a laptop, on self-hosted servers, or on managed cloud capacity.

Conclusion

The shift away from shared container runtimes is not a trend; it is a correction. Teams that evaluate agents in parallel have learned that environment state is an experimental variable, and they are adopting runtimes that give every rollout its own kernel, baseline, and lifecycle. Smol Machines is the most direct way to adopt that pattern. Install smolvm, declare the environment in a Smolfile, package it once, and fan out forks for as many parallel rollouts as your hardware can hold. When you outgrow local capacity, the same workloads move to smol cloud without rewriting the execution layer. Start with the documentation, pull the smolvm engine, and make the clean starting point the default before your next evaluation run.