awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
deeplethe avatar

deeplethe/sandstorm

0
View on GitHub↗

Sandstorm

Sandstorm is a self-hosted platform for running large numbers of isolated sandboxes for AI agents across a cluster of machines. A central master places sandboxes onto worker nodes, which join by pairing code or dial out from behind a NAT. Each node isolates workloads with either Firecracker microVMs or gVisor, a user-space kernel for hosts without KVM. Master, node, and web console roles ship in a single executable.

What sets it apart is density and start speed. Children are forked from a warmed parent snapshot using shared copy-on-write memory, so many sandboxes start in milliseconds without booting their own kernel. Idle sandboxes step down through running, frozen, checkpointed, and detached tiers, and a per-node gateway wakes a sleeping sandbox when a request arrives, so far more sandboxes can exist than could run at once. It also exposes an E2B-compatible control API so official E2B Python and JavaScript SDKs work against it unchanged, and an MCP tool server so assistants and editors can spawn, fork, and drive sandboxes.

Beyond that, the platform covers snapshots and branching (tag-based forking, incremental chains, live branching of a running sandbox, and portable archives), templates built from container images or prebuilt runtime recipes, and command execution and code evaluation inside sandboxes. Security controls include per-sandbox tokens, mutual TLS between cluster components, front-door TLS, and default-deny egress policies. Operators get a web admin console, one-command node enrollment, Prometheus metrics, audit logs, and load-testing and benchmarking tools for start latency and memory footprint. Python and TypeScript SDKs and a command-line tool are included, and a single installer script and systemd service files handle setup.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • MicroVM Agent Sandboxes - Runs thousands of isolated AI agent sandboxes as microVMs on low-cost machines, with fast forking, snapshots, and idle-state tiering.
  • Tiered Sandbox Idle States - Steps idle sandboxes down through hot, frozen, checkpointed and detached tiers, so far more sandboxes can exist than could run at once.
  • Tiered Idle Suspensions - Steps idle sandboxes down through running, frozen, checkpointed, and detached tiers so far more sandboxes can exist than could run at once.
  • E2B-Compatible APIs - Serves an E2B-compatible control API and per-sandbox hosts so official Python and JavaScript SDKs work by setting only a domain and key.
  • Master and Worker Node Orchestration - Keeps desired state on one master that places sandboxes onto worker nodes, which join by pairing code or dial out from behind a NAT.
  • MicroVM Orchestrators - Manages a multi-node cluster that places, forks, snapshots, and wakes Firecracker microVMs, with gVisor for hosts lacking KVM.
  • Sandbox Fleet Density Optimization - Packs far more idle sandboxes onto cheap hardware by suspending them through tiers and waking them when traffic arrives.
  • Sandbox Forking - Forks many isolated microVMs from one warmed parent snapshot with shared copy-on-write memory, so children start in milliseconds without booting a kernel.
  • Self-Hosted Sandbox Deployments - Lets official E2B SDKs and MCP-aware assistants target self-hosted sandbox infrastructure instead of the hosted service, with no code changes.
  • Wake on Incoming Traffic - Detects requests for suspended sandboxes at the node gateway, restores them in a fraction of a second, pausing least-used ones to make room.
  • Snapshot Fork Restores - Restores child sandboxes from a shared warmed snapshot with copy-on-write pages so many start in milliseconds without booting a kernel.
  • MicroVM Sandboxes - Runs every child as its own KVM-backed microVM with a separate network namespace, memory limit and reseeded randomness for multi-tenant safety.
  • MCP Tool Servers - Serves MCP tools that spawn sandboxes, run commands, and evaluate code so assistants and editors can fork and drive microVMs.
  • Snapshot Tag Forking - Creates child sandboxes from a saved tag, placing each on the least loaded compatible node and fetching the image from the source node when missing.
  • Sandbox Command Executions - Executes a command inside a running sandbox, waits up to a timeout, and returns standard output, standard error and exit code.
  • Python SDKs - Offers Python and TypeScript SDKs with matching options to create sandboxes, trust a private CA, wait until running, and call exec, eval, branch and touch.
  • MCP Client and Server Implementations - Serves an MCP tool server so assistants and editors can spawn, fork and drive sandboxes, run commands and evaluate code.
  • Node-Judged Capacity Placement - Lets each node judge whether it can accept a new sandbox, keeping placement accurate without central load tracking.
  • Wake-on-Request Gateways - A per-node gateway intercepts requests for sleeping sandboxes, restores them from disk, and forwards the held request once ready.
  • Sandbox Backends - Supports interchangeable microVM and user-space isolation backends behind a common interface, running on KVM hosts and PVM-capable machines.
  • Warm Snapshot Restores - Starts ready-to-use sandboxes in milliseconds by restoring warm templates and snapshots rather than cold-booting each machine.
  • Running Sandbox Checkpoints - Saves a running sandbox as a named tag that new sandboxes can fork from, while the original continues after a brief pause.
  • Single-Binary Deployments - Packages master, node, and web console roles into one executable so a cluster needs only a single artifact to install.
  • Template-Based Sandbox Launches - Starts one or many isolated sandboxes from a template or snapshot tag with placement, memory ceiling, volume and token options.
  • Warm Template Startups - Restores a snapshot of an already-started application instead of booting, so new sandboxes become ready in a fraction of the time.
  • Sandbox Port Gateways - Exposes any sandbox port through a node gateway that checks the sandbox token, streams bodies, supports WebSockets and refuses cold sandboxes.
  • User-Space Kernel Isolation - Isolates each sandbox inside a user-space kernel so low-cost hosts without hardware virtualization can still separate workloads.
  • Sandbox Egress Controls - Blocks outside network access by default and lets operators set per-sandbox policies allowing the public internet or specific IPv4 addresses and CIDRs, with deny rules.
  • Mutual TLS Transport Encryption - Encrypts and mutually authenticates all node-to-master traffic with certificates whichever side initiates, pins the master certificate in tokens, and supports node revocation.
  • Untrusted Code Sandboxes - Runs untrusted or generated code in separate microVMs with locked-down networking, per-sandbox tokens, and mutual TLS between machines.
  • Pluggable Backends - Isolates sandboxes through a common interface that can be backed by either a user-space kernel or a KVM microVM, chosen automatically or explicitly.
  • Frozen Sandbox Memory Reclamation - Moves cold pages of paused sandboxes into compressed in-memory swap, sharply cutting held memory while resumed sandboxes stay responsive.
  • Sandbox Start Latency Benchmarks - Times each sandbox from the start call to its first successful web response, polling every few milliseconds, to report readiness speed.
5,452 stars·426 forks·Rust·Apache-2.0·2 views

Star history

Star history chart for deeplethe/sandstormStar history chart for deeplethe/sandstorm

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does deeplethe/sandstorm do?

Sandstorm is a self-hosted platform for running large numbers of isolated sandboxes for AI agents across a cluster of machines. A central master places sandboxes onto worker nodes, which join by pairing code or dial out from behind a NAT. Each node isolates workloads with either Firecracker microVMs or gVisor, a user-space kernel for hosts without KVM. Master, node, and web console roles ship in a single executable.

What are the main features of deeplethe/sandstorm?

The main features of deeplethe/sandstorm are: MicroVM Agent Sandboxes, Tiered Sandbox Idle States, Tiered Idle Suspensions, E2B-Compatible APIs, Master and Worker Node Orchestration, MicroVM Orchestrators, Sandbox Fleet Density Optimization, Sandbox Forking.

Which projects share features with deeplethe/sandstorm?

Projects with overlapping indexed features include: kvcache-ai/agentenv — AgentENV is a distributed sandbox platform that launches isolated Firecracker microVMs across many machines, so AI… elie222/rakazo — Rakazo is a self-hosted, open-source platform of persistent AI bots. Each bot keeps its own conversations, memory,… superradcompany/microsandbox — Microsandbox is a runtime for creating and managing lightweight, hardware-isolated virtual machines — called sandboxes… agent-substrate/substrate — Substrate is a Kubernetes-based platform for running AI agents as persistent actors. Each actor keeps its memory and… zerocore-ai/microsandbox — microsandbox is a platform that runs untrusted code inside hardware-isolated microVMs, each with its own kernel,… mattpocock/sandcastle — Sandcastle is a TypeScript library for launching AI coding agents from scripts or CI pipelines and running them…

Projects sharing features with Sandstorm

These projects share indexed features with Sandstorm. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • kvcache-ai/agentenvkvcache-ai avatar

    kvcache-ai/AgentENV

    3,730View on GitHub↗

    AgentENV is a distributed sandbox platform that launches isolated Firecracker microVMs across many machines, so AI agents can run their workloads in parallel and at scale. Each environment gets its own dedicated Linux kernel, and a gateway and scheduler control plane places and manages environments across a multi-node cluster. It also serves an E2B-compatible HTTP API, so existing E2B Python and TypeScript SDK code works unchanged against your own infrastructure. Environments are snapshot-driven. The runtime captures incremental memory and disk snapshots, pauses and resumes idle environments

    Rust
    View on GitHub↗3,730
  • elie222/rakazoelie222 avatar

    elie222/rakazo

    7,458View on GitHub↗

    Rakazo is a self-hosted, open-source platform of persistent AI bots. Each bot keeps its own conversations, memory, scheduled routines, and history, and can hand work to peer bots or short-lived helper agents. Bots get isolated shared or private computers with a browser, terminal, files, and a graphical desktop, and users can watch a bot's screen and take control of it when needed. The same bots are reachable from web, desktop, and mobile apps, and from messaging channels such as iMessage, Slack, Telegram, and WhatsApp. The model and the computer are both your choice. You can connect your own

    TypeScriptai-agentschatgptdocker
    View on GitHub↗7,458
  • superradcompany/microsandboxsuperradcompany avatar

    superradcompany/microsandbox

    6,570View on GitHub↗

    Microsandbox is a runtime for creating and managing lightweight, hardware-isolated virtual machines — called sandboxes — that boot directly from standard OCI container images. Each sandbox runs as its own host process with a separate kernel, filesystem, and network stack, providing process-per-sandbox isolation. The project includes a command-line tool and multi-language SDKs (Rust, TypeScript, Python, Go) for programmatic lifecycle control, and it communicates with sandbox agents over Unix sockets using a CBOR-encoded protocol. What distinguishes Microsandbox is its combination of host-manag

    Rust
    View on GitHub↗6,570
  • agent-substrate/substrateagent-substrate avatar

    agent-substrate/substrate

    6,195View on GitHub↗

    Substrate is a Kubernetes-based platform for running AI agents as persistent actors. Each actor keeps its memory and filesystem state across idle periods: when it goes quiet, it is snapshotted to durable object storage and its worker is freed, and it is later restored onto any available worker when a request arrives. Agents built on any framework can run from standard container images without code changes, and each untrusted agent runs in its own gVisor or microVM sandbox with separate compute, network, and storage. What sets it apart is the combination of density and containment. Because mos

    Goagentscncfsandboxing
    View on GitHub↗6,195
Compare all 30 related projects→