by boxlite-ai
Compute substrate for AI agents: lightweight enough to live on your laptop, elastic enough to scale into the cloud and unleash unlimited resources.
# Add to your Claude Code skills
git clone https://github.com/boxlite-ai/boxliteLast scanned: 5/14/2026
{
"issues": [],
"status": "PASSED",
"scannedAt": "2026-05-14T06:46:16.567Z",
"semgrepRan": false,
"npmAuditRan": true,
"pipAuditRan": true
}Compute substrate for AI agents: lightweight enough to live on your laptop, elastic enough to scale into the cloud and unleash unlimited resources.
BoxLite lets you spin up lightweight VMs ("Boxes") and run OCI containers inside them. Unlike ephemeral sandboxes that destroy state after each execution, BoxLite Boxes are persistent workspaces — install packages, create files, build up environment state, then come back later and pick up where you left off.
Why BoxLite
No comments yet. Be the first to share your thoughts!
python:slim, node:alpine, alpine:latest).allow_net and inject real HTTP(S) secrets from host-side secrets.pip install boxlite
Requires Python 3.10+.
import asyncio
import boxlite
async def main():
async with boxlite.SimpleBox(image="python:slim") as box:
result = await box.exec("python", "-c", "print('Hello from BoxLite!')")
print(result.stdout)
asyncio.run(main())
npm install @boxlite-ai/boxlite
Requires Node.js 18+.
import { SimpleBox } from '@boxlite-ai/boxlite';
async function main() {
const box = new SimpleBox({ image: 'python:slim' });
try {
const result = await box.exec('python', '-c', "print('Hello from BoxLite!')");
console.log(result.stdout);
} finally {
await box.stop();
}
}
main();
cargo add boxlite tokio futures --features tokio/macros,tokio/rt-multi-thread
use boxlite::{BoxCommand, BoxOptions, BoxliteRuntime, RootfsSpec};
use futures::StreamExt;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let runtime = BoxliteRuntime::default_runtime();
let options = BoxOptions {
rootfs: RootfsSpec::Image("alpine:latest".into()),
..Default::default()
};
let litebox = runtime.create(options, None).await?;
let mut execution = litebox
.exec(BoxCommand::new("echo").arg("Hello from BoxLite!"))
.await?;
let mut stdout = execution.stdout().unwrap();
while let Some(line) = stdout.next().await {
println!("{}", line);
}
Ok(())
}
go get github.com/boxlite-ai/boxlite/sdks/go
go run github.com/boxlite-ai/boxlite/sdks/go/cmd/setup
Requires Go 1.24+ with CGO enabled. The setup step downloads the prebuilt native library (one-time).
package main
import (
"context"
"fmt"
"log"
boxlite "github.com/boxlite-ai/boxlite/sdks/go"
)
func main() {
rt, err := boxlite.NewRuntime()
if err != nil {
log.Fatal(err)
}
defer rt.Close()
ctx := context.Background()
box, err := rt.Create(ctx, "alpine:latest", boxlite.WithName("my-box"))
if err != nil {
log.Fatal(err)
}
defer box.Close()
result, err := box.Exec(ctx, "echo", "Hello from BoxLite!")
if err != nil {
log.Fatal(err)
}
fmt.Print(result.Stdout)
}
curl -fsSL https://sh.boxlite.ai | sh
Installs to $HOME/.local/bin/boxlite. The runtime is embedded in the
binary — no extra setup. For alternatives (cargo install boxlite-cli,
version pinning, custom install dir) and release-artifact verification,
see the CLI Reference's Installation & Verification section.
boxlite run python:slim python -c "print('Hello from BoxLite!')"
Install the boxlite CLI — see CLI Quick Start. The
REST server ships with the same binary. For release-artifact verification,
see the CLI Reference's Installation & Verification section.
boxlite serve
# Listening on 0.0.0.0:8100
# Create a box
curl -s -X POST http://localhost:8100/v1/default/boxes \
-H 'Content-Type: application/json' \
-d '{"image": "alpine:latest"}'
# Run a command (replace BOX_ID from the response above)
curl -s -X POST http://localhost:8100/v1/default/boxes/BOX_ID/exec \
-H 'Content-Type: application/json' \
-d '{"command": "echo", "args": ["Hello from BoxLite!"]}'
All CLI commands also work against a running server:
boxlite --url http://localhost:8100 list
boxlite --url http://localhost:8100 exec BOX_ID -- echo "Hello!"
--config), CLI flags (--registry), or SDK options. See the configuration guide.boxlite serve) — use BoxLite from any language or tool via curlHigh-level overview of how BoxLite embeds a runtime and runs OCI containers inside micro-VMs. For details, see Architecture.
┌──────────────────────────────────────────────────────────────┐
│ Your Application │
│ ┌───────────────────────────────────────────────────────┐ │
│ │ BoxLite Runtime (embedded library) │ │
│ │ │ │
│ │ ╔════════════════════════════════════════════════╗ │ │
│ │ ║ Jailer (OS-level sandbox) ║ │ │
│ │ ║ ┌──────────┐ ┌──────────┐ ┌──────────┐ ║ │ │
│ │ ║ │ Box A │ │ Box B │ │ Box C │ ║ │ │
│ │ ║ │ (VM+Shim)│ │ (VM+Shim)│ │ (VM+Shim)│ ║ │ │
│ │ ║ │┌────────┐│ │┌────────┐│ │┌────────┐│ ║ │ │
│ │ ║ ││Container││ ││Container││ ││Container││ ║ │ │
│ │ ║ │└────────┘│ │└────────┘│ │└────────┘│ ║ │ │
│ │ ║ └──────────┘ └──────────┘ └──────────┘ ║ │ │
│ │ ╚════════════════════════════════════════════════╝ │ │
│ └───────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────┘
│
Hardware Virtualization + OS Sandboxing
(KVM/Hypervisor.framework + seccomp/sandbox-exec)
Security Layers:
boxlite CLI reference| Platform | Architecture | Status | |----------------|-----------------------|------------------| | macOS | Apple Silicon (ARM64) | ✅ Supported | | Linux | x86_64 | ✅ Supported | | Linux | ARM64 | ✅ Supported | | Windows (WSL2) | x86_64 | ✅ Supported | | macOS | Intel (x86_64) | 🚀 Coming soon |
| Platform | Requirements |
|----------------|------------------------------------------------|
| macOS | Apple Silicon, macOS 12+ |
| Linux | KVM enabled (/dev/kvm accessible) |
| Windows (WSL2) | WSL2 with KVM support, user in kvm group |