smol machines (smolvm)
Apache-2.0 runtime that boots OCI images as branchable libkrun microVMs on macOS, Linux and Windows, with checkpoints, portable .smolmachine files and a hosted smol cloud behind the same SDK. An open-source libkrun microVM runtime built around branching and portable checkpoints, with a usage-billed hosted cloud on the same API.
Overview
smol machines makes smolvm, an Apache-2.0 microVM runtime that boots any OCI image as a Linux VM with its own kernel, using libkrun as the VMM and its own libkrunfw guest kernel, on macOS (Apple Silicon), Linux with KVM and Windows with the Windows Hypervisor Platform. The VMM is linked into the binary, so no Docker or host daemon is needed, and memory is elastic through virtio balloon. The project describes itself as "Branchable microVMs for AI agents": a running machine can be branched into copy-on-write children, checkpointed with RAM and CPU state, paused and resumed, or packed into a portable .smolmachine file that runs as a self-contained executable or is pushed to an OCI registry. It is not Celesto's SmolVM (listed separately); the README says smolvm "is not affiliated with other projects named SmolVM".
The same Machine API is available in TypeScript, Python, Rust and Go SDKs that embed the engine in-process or connect to smol cloud, the company's hosted service. smol cloud bills a $0.04 base per running machine-hour plus measured CPU, memory, disk and egress, with plans from $0 to $150 a month and a one-time $100 credit; idle machines can auto-stop or pause, and a paused machine with a published port resumes on its next request. Locally, smolvm adds GPU access through Vulkan (virtio-gpu/Venus) and CUDA API remoting, but the docs say smol cloud has no GPU machines. The website shows a Y Combinator (S26) badge.
Notable
- Release v1.35.4 on 18 November 2026; 7,139 GitHub stars at verification.
- Checkpoints capture RAM, CPU state and disks; a checkpoint taken on an arm64 Mac resumes on arm64 Linux or on smol cloud.
- README claims <200 ms to agent ready, and a packed .smolmachine executable boots in under 200 ms (vendor claims).
smol machines (smolvm) specifications
| Attribute | Details |
|---|---|
| Isolation | Hardware-virtualized microVM with its own guest kernel for every workload: libkrun as the VMM and smol machines' libkrunfw guest kernel, on Hypervisor.framework (macOS), KVM (Linux) or the Windows Hypervisor Platform; the VMM is linked into the binary with no host daemon. smol cloud runs each machine in its own hardware-isolated microVM |
| Deployment | Open-source project · Self-hostable |
| Open source | Yes (Apache-2.0) |
| SDKs and interfaces | JavaScript/TypeScript, Python, Rust, Go, CLI, REST API |
| Cold start (vendor claim) | README comparison table: "<200ms to agent ready"; local VMs "boot in under a second" and a packed .smolmachine executable "boots in under 200 ms" (vendor claims). smol cloud machines start from warm pools |
| Max session length | Not documented |
| Persistence | Local machines created with machine create keep installed packages and state across restarts; machine run VMs are removed on exit. Checkpoints capture RAM, CPU state and disks and can be restored on another host or on smol cloud; branches are copy-on-write children of a live machine; a machine can be packed into a portable .smolmachine file and pushed to an OCI registry. On smol cloud the machine filesystem persists across exec and stop/start (not /tmp), and a stop exports a recovery point |
| GPU | Local smolvm only: Vulkan via virtio-gpu/Venus, and CUDA API remoting over vsock to a host NVIDIA GPU (not passthrough); Vulkan is unavailable on native Windows. The docs state that hosted smol cloud does not provide GPU machines |
| Networking | Networking is off by default; egress can be limited to named hosts, host patterns or CIDRs, and the allow list can be changed on a running machine. Credential substitution lets code use a secret bound to specific hosts while the guest sees a placeholder. Local --auto-ports mirrors listening guest ports onto 127.0.0.1; named networks let machines reach each other. smol cloud offers blocked, open and allowCidrs modes, published ports and optional public ingress |
| Pricing | smol cloud: base $0.04 per running machine-hour (1-minute minimum), plus $0.05 per active vCPU-hour, $0.0162 per GB-hour of memory in use, $0.0001 per GB-hour of disk used (~$0.073/GB-month) and $0.05 per GB egress; a beta 10% discount on spend above $2,000 a month. Plans: Standard $0 (20 machines, 8 vCPU and 16 GB per machine), Pro $20 a month plus usage (100 machines, 16 vCPU, 24 GB, 200 GB disk, 99.95% SLA), Startup $150 a month plus usage (1,000 machines, 32 vCPU, 32 GB, 200 GB disk, priority support), Enterprise custom. Local and self-hosted smolvm is free |
| Free tier | One-time $100 sign-up credit on smol cloud, no card needed to start (up to 4 machines of up to 4 vCPU each until a card is added); smolvm is free to run locally or self-host |
| Compliance | Not documented |
| Regions | No region list is published; the privacy policy names Google Cloud (US regions) as compute infrastructure and says data is processed in the United States |
| Company headquarters | Not documented |
Facts from smol machines (smolvm)’s public documentation, verified November 18, 2026. Performance numbers are vendor claims.
Strengths and trade-offs
Strengths
- You want hardware-isolated microVMs that run natively on a Mac, a Linux server or Windows from the same CLI and SDK.
- You fan out agent tasks or RL rollouts by branching a warm, running machine instead of booting fresh ones.
- You want to checkpoint a running machine and move it between hosts or into a hosted cloud.
- You need egress allow-lists and credentials the guest code never reads.
Trade-offs
- GPU support is local only; the docs say hosted smol cloud does not provide GPU machines.
- Guest architecture must match the host, and checkpoints do not restore across architectures.
- Compliance certifications and a hosted region list are not published.
- Intel macOS has no published release build and is listed as untested.
Good fit for: Branching and checkpointing microVMs locally for agents and RL rollouts, then running the same machine on a hosted cloud.
How smol machines (smolvm) compares
| Sandbox | Company HQ | Isolation | Open source | Self-host / BYOC | Cold start (vendor) | Max session | Snapshots / pause | GPU | SDKs |
|---|---|---|---|---|---|---|---|---|---|
| smol machines (smolvm) | Not documented | libkrun microVM | Yes | Yes / Not documented | <200 ms (claim) | Not documented | Yes / Yes | Yes | JavaScript/TypeScript, Python, Rust, Go, CLI, REST API |
| Celesto (SmolVM) | Not documented | Firecracker / QEMU microVM | Yes | Yes / Not documented | ~500 ms (claim) | Not documented | Yes / Yes | Not documented | Python, JavaScript/TypeScript, CLI, MCP server |
| Microsandbox | Not documented | MicroVM (libkrun) | Yes | Yes / Yes | <100 ms | Not documented | Yes / Not documented | Not documented | TypeScript, Python, Rust, Go, Ruby, CLI, MCP server |
| BoxLite | Not documented | microVM + jailer | Yes | Yes / Not documented | ~1 s (claim) | Not documented | Not documented / Not documented | Not documented | Python, JavaScript/TypeScript, Go, Rust, C, CLI, REST API |
| libkrun | Not documented | In-process microVM | Yes | Yes / No | Not documented | Not documented | Not documented / Not documented | Yes | Rust, C |
| Pullrun | Not documented | Firecracker / Apple VM / runc | Yes | Yes / No | ~500 ms (claim) | Not documented | Yes / Not documented | Not documented | CLI, MCP server |
| Morph Cloud | Not documented | VM | No | Not documented / Not documented | <250 ms (restore) | Configurable | Yes / Yes | Not documented | Python, TypeScript |
Head-to-head: Celesto (SmolVM) vs smol machines (smolvm) · smol machines (smolvm) vs Zeroboot
Frequently asked questions
What is smol machines (smolvm)?
How does smol machines (smolvm) isolate code?
Is smol machines (smolvm) open source?
How much does smol machines (smolvm) cost?
Does smol machines (smolvm) support GPUs?
Does smol machines (smolvm) support snapshots or pause and resume?
machine create keep installed packages and state across restarts; machine run VMs are removed on exit. Checkpoints capture RAM, CPU state and disks and can be restored on another host or on smol cloud; branches are copy-on-write children of a live machine; a machine can be packed into a portable .smolmachine file and pushed to an OCI registry. On smol cloud the machine filesystem persists across exec and stop/start (not /tmp), and a stop exports a recovery point.Which regions does smol machines (smolvm) run in?
What are the alternatives to smol machines (smolvm)?
Sources
- smolmachines.com
- smolmachines.com/pricing
- smolmachines.com/faq
- smolmachines.com/docs/
- smolmachines.com/docs/cloud
- smolmachines.com/docs/cloud/lifecycle-storage-networking
- smolmachines.com/docs/introduction/concepts/gpu
- smolmachines.com/legal/privacy
- smolmachines.com/legal/terms
- github.com/smol-machines/smolvm
- github.com/smol-machines/smolvm/blob/main/docs/limitations.md
- github.com/smol-machines/smolvm/blob/main/docs/gpu.md
- github.com/smol-machines/smol
Check before you rely on it. Products change quickly, and this page reflects public documentation as of November 18, 2026. Confirm anything that matters in the provider’s own documentation.
Cite this page
Agent Sandboxes. (2026). smol machines (smolvm). agentsandboxes.org. Last reviewed November 18, 2026. https://agentsandboxes.org/sandboxes/smol-machines/