# Microsandbox – local-first programmable micro VMs > Source: > Published: 2026-06-06 12:39:12+00:00 **—— the easiest way to give your agent their own computer ——** **Microsandbox** spins up **lightweight VMs in milliseconds** from our SDKs. Runs locally on your machine. No server to set up. No lingering daemon. It is all embedded and rootless! **Hardware Isolation**: Hardware-level isolation with microVM technology.** Instant Startup**: Average boot times under 100 milliseconds.** Embeddable**: Spawn VMs right within your code. No setup server. No long-running daemon.** Secrets That Can't Leak**: Unexploitable secret keys that never enter the VM.** OCI Compatible**: Runs standard container images from Docker Hub, GHCR, or any OCI registry.** Long-Running**: Sandboxes can run in detached mode. Great for long-lived sessions.** Agent-Ready**: Your agents can create their own sandboxes with our[Agent Skills](https://github.com/superradcompany/skills)and[MCP server](https://github.com/superradcompany/microsandbox-mcp). ``` cargo add microsandbox # 🦀 Rust uv add microsandbox # 🐍 Python npm i microsandbox # 🟦 TypeScript go get github.com/superradcompany/microsandbox/sdk/go # 🐹 Go ``` Boot a microVM in one command. ``` npx microsandbox run debian ``` Or install the `msb` command globally: ``` curl -fsSL https://install.microsandbox.dev | sh ``` On macOS you can also install with Homebrew: ``` brew install superradcompany/tap/microsandbox msb run debian ``` Requirements: Linux with KVM enabled, or macOS with Apple Silicon. Warning: Microsandbox is stillbeta software. Expect breaking changes, missing features, and rough edges. The SDK lets you create and control sandboxes directly from your application. `Sandbox::builder("...").create()` boots a microVM as a child process. No infrastructure required. ``` php use microsandbox::Sandbox; #[tokio::main] async fn main() -> Result<(), Box> { let sandbox = Sandbox::builder("my-sandbox") .image("python") .cpus(1) .memory(512) .create() .await?; let output = sandbox .exec("python", ["-c", "print('Hello from a microVM!')"]) .await?; println!("{}", output.stdout()?); sandbox.stop_and_wait().await?; Ok(()) } ``` Python Example → ``` python import asyncio from microsandbox import Sandbox async def main(): sandbox = await Sandbox.create( "my-sandbox", image="python", cpus=1, memory=512, ) output = await sandbox.exec("python", ["-c", "print('Hello from a microVM!')"]) print(output.stdout_text) await sandbox.stop_and_wait() asyncio.run(main()) ``` TypeScript Example → ``` js import { Sandbox } from "microsandbox"; await using sandbox = await Sandbox.builder("my-sandbox") .image("python") .cpus(1) .memory(512) .create(); const output = await sandbox.exec("python", ["-c", "print('Hello from a microVM!')"]); console.log(output.stdout()); ``` Go Example → ``` package main import ( "context" "fmt" "log" microsandbox "github.com/superradcompany/microsandbox/sdk/go" ) func main() { ctx := context.Background() // Downloads the microsandbox runtime to ~/.microsandbox/ on first run. if err := microsandbox.EnsureInstalled(ctx); err != nil { log.Fatal(err) } sandbox, err := microsandbox.CreateSandbox(ctx, "my-sandbox", microsandbox.WithImage("python"), microsandbox.WithCPUs(1), microsandbox.WithMemory(512), ) if err != nil { log.Fatal(err) } defer sandbox.StopAndWait(ctx) output, err := sandbox.Exec(ctx, "python", []string{"-c", "print('Hello from a microVM!')"}) if err != nil { log.Fatal(err) } fmt.Println(output.Stdout()) } ``` The first call to `create()` pulls the image if it isn't cached locally, so it may take longer depending on your connection. Subsequent runs reuse the cache. The `msb` CLI provides a complete interface for managing sandboxes, images, and volumes. ``` msb run python -- python3 -c "print('Hello from a microVM!')" # Create and start a named sandbox msb create --name my-app python python # Execute commands msb exec my-app -- python -c "import this" msb exec my-app -- curl https://example.com # Lifecycle msb stop my-app msb start my-app msb rm my-app msb pull python # Pull an image msb image ls # List cached images msb image rm python # Remove an image msb install ubuntu # Install ubuntu sandbox as 'ubuntu' command ubuntu # Opens Ubuntu in a microVM msb uninstall ubuntu # Uninstall the ubuntu sandbox msb ls # List all sandboxes msb ps my-app # Show sandbox status msb inspect my-app # Detailed sandbox info msb metrics my-app # Live CPU/memory/network stats ``` Tip Run `msb --tree` to see all available commands and their options. Give your AI agents the ability to create and manage their own sandboxes. Teach any AI coding agent how to use microsandbox by installing the [Agent Skills]. Works with Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and more. ``` npx skills add superradcompany/skills ``` Connect any MCP-compatible agent to microsandbox with the [MCP server]. Provides structured tool calls for sandbox lifecycle, command execution, filesystem access, volumes, and monitoring. ``` # Claude Code claude mcp add --transport stdio microsandbox -- npx -y microsandbox-mcp ``` For guides, API references, and examples, visit the [microsandbox documentation](https://docs.microsandbox.dev). Interested in contributing to `microsandbox` ? Check out our [CONTRIBUTING.md](/superradcompany/microsandbox/blob/main/CONTRIBUTING.md) for guidelines and [DEVELOPMENT.md](/superradcompany/microsandbox/blob/main/DEVELOPMENT.md) for build, test, and release instructions. This project is licensed under the [Apache License 2.0](/superradcompany/microsandbox/blob/main/LICENSE). Special thanks to all our contributors, testers, and community members who help make microsandbox better every day! We'd like to thank the following projects and communities that made `microsandbox` possible: [libkrun](https://github.com/containers/libkrun) and [smoltcp](https://github.com/smoltcp-rs/smoltcp)