Serveur MCP sandbox
Commit 14 nov. 2026Fournit des sandboxes MicroVM à démarrage rapide pour les agents IA en utilisant la pile guest cocoon.
Aussi connu sous cocoonstack/sandbox
- Étoiles
- 89
- Outils
- —
- Téléchargements, 30 jours
- —
- Dernière version
- —
- Dernier commit
- 14 nov. 2026
- Licence
- AGPL-3.0
Qu'est-ce que sandbox MCP ?
Fournit des sandboxes MicroVM à démarrage rapide pour les agents IA en utilisant la pile guest cocoon.
Résumé généré à partir du README du projet
À propos du MCP server sandbox
Ce serveur permet de fournir des sandboxes MicroVM à démarrage rapide pour les agents IA grâce à la pile guest cocoon. Il permet aux développeurs de créer des environnements d'exécution isolés pouvant être récupérés en moins d'une milliseconde via des pools à chaud. En cas d'échec de récupération dans un pool (pool miss), le système effectue un clonage à partir d'un snapshot de référence en quelques dizaines de millisecondes, tandis qu'un démarrage à froid sur bare metal prend environ 0,2 à 0,4 seconde.
Pour utiliser ce serveur, vous devez exécuter sandboxd sur un nœud Linux équipé de KVM, Cloud Hypervisor et jq. La configuration nécessite un fichier spécifiant une adresse d'écoute, un jeton API et des modèles de pool. Une fois le plan de contrôle opérationnel, les agents IA peuvent interagir avec ces environnements via les SDK Go ou Python, ou via le serveur MCP stdio dédié. Cette architecture est conçue pour les charges de travail haute performance où le provisionnement rapide d'environnements est critique pour les workflows agentiques.
Ce que vous pouvez faire avec
- 1Provisionnement rapide d'environnements d'exécutionUn agent IA peut demander une nouvelle instance de sandbox pour exécuter du code non fiable avec une latence inférieure à la milliseconde en utilisant des warm claims.
Extrait du README du projet. Chaque cas d'utilisation est vérifié par rapport à une citation du document.
Vérifications automatisées
Exécuté le 14 nov. 2026Rapport complet →Pas encore vérifié. Un serveur nécessite un score de 80, aucune faille sérieuse et suffisamment de données pour que nous puissions effectuer les vérifications. Fonctionnement des vérifications · Ce qu'il faut corriger pour gagner des points
- Dépôt source lié et accessiblecocoonstack/sandbox is public and reachablegithub.com/cocoonstack/sandbox ↗Réussi
- Le nom du package correspond au dépôt sourceNon vérifié
- Provenance du build (attestation Sigstore)Non vérifié
- Licence open source (OSI)AGPL-3.0spdx.org/licenses/AGPL-3.0.html ↗Réussi
- Commit ou version publiée au cours de l'année écouléeLast commit or release 2026-11-14github.com/cocoonstack/sandbox ↗Réussi
- OpenSSF ScorecardNon vérifié
- Nom du package non proche d'un package populaireNon vérifié
- Aucun avis critique dans le package ou ses dépendancesNon vérifié
- Aucune instruction cachée destinée au modèle0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersRéussi
- Les outils destructifs sont étiquetésNon vérifié
- Le point de terminaison distant répond à la poignée de main MCPNon vérifié
README
Voir sur GitHubsandbox
MicroVM sandboxes for AI agents, built on cocoon: a fast-boot guest stack, an in-guest product daemon, a per-node control plane with warm pools, and SDKs for Go and Python. Warm claims are sub-millisecond; a pool miss clones from a golden snapshot in tens of milliseconds; cold boot is ~0.2–0.4 s on bare metal.
Documentation: cocoonstack.github.io/sandbox
(source in docs/); the architecture overview is in
docs/index.md.
Quick start
On a Linux node with KVM, cocoon v0.6.9
or newer, Cloud Hypervisor and jq, as root, from a checkout with Go installed.
Not on a node that already runs sandboxd on the same cocoon root: at start
sandboxd removes every sbx- VM it does not own.
make sandboxd
cocoon image pull ghcr.io/cocoonstack/sandbox/rt:24.04
cat >config.json <<'EOF'
{
"listen": "127.0.0.1:7777",
"api_token": "change-me",
"pools": [
{"template": "ghcr.io/cocoonstack/sandbox/rt:24.04", "net": "none", "size": "small", "warm": 2}
]
}
EOF
dist/sandboxd -config config.json &
# Wait for the golden snapshot and the warm pool.
until curl -sf -H 'Authorization: Bearer change-me' http://127.0.0.1:7777/v1/info |
jq -e '(.pools | length) > 0 and all(.pools[]; .golden and .warm >= .target)' >/dev/null; do sleep 1; done
# Claim, exec and release three times; prints each latency.
(cd e2e && GOWORK=off go run ./cmd/demo -addr 127.0.0.1:7777 -token change-me \
-template ghcr.io/cocoonstack/sandbox/rt:24.04)
A stopped sandboxd leaves its VMs for the next start. To remove them:
kill %1
cocoon vm list --format json | jq -r '.[].config.name | select(startswith("sbx-"))' |
while read -r vm; do cocoon vm stop --force "$vm"; cocoon vm rm --force "$vm"; done
demo is a small program over the Go SDK; the
Python SDK has the same calls. Deploying
sandboxd covers release binaries, the full config and systemd.
Related projects
- cocoon — the microVM engine underneath
- vk-sandbox — the Kubernetes provider that claims from sandboxd
- sandbox-operator — the Kubernetes apiserver and e2b-compatible data plane over warm pools
Layout
silkd/— in-guest product daemon (Rust), baked into the base image; newline-JSON frames over vsock 2048 (reference)sandboxd/— per-node control plane (Go): warm pools, the claim API and the relays to silkd (deploy, API)sdk/go/— Go SDK;sdk/go/silkd/is its connection layer andsdk/go/silkd/silkdtest/a test fakesdk/python/— Python SDK, stdlib-only and synchronousmcp/—sandbox-mcp, an MCP stdio serversdk/openai/—cocoonstack-sandbox-openai, a sandbox provider for the OpenAI Agents SDKsdk/langchain/—cocoonstack-sandbox-langchain, a LangChain toolkitprotocol/wire/— the frame vocabulary andfixtures/, the golden corpus the Rust, Go and Python tests check, so wire drift fails CIe2e/— in-process full-stack tests (real pool/engine/relay/SDK, fake cocoon + guest) and the bare-metal driversboot/kernel/— kernel version pin (VERSION+ matching tarballSHA256, bump both together) and config fragmentsboot/init/—sandbox-init, the entire initramfs userland (static Rust)boot/Dockerfile— multi-stage: kernel → init → cpio → scratch image with/boot/vmlinuz-sandbox+/boot/initrd.img-sandboxos-image/— VM images consuming the boot artifact:base,rt,python,python-rt,node,node-rt,browser,android,e2b-rt,e2b-ciscripts/— benchmarks and bare-metal e2e, see Verifying a nodepackaging/— the systemd unit deploy installs
CI
silkd.yml/sandboxd.yml— Rust and Go test+lint suitesboot-init.yml— the boot/init crate's own fmt+clippy+test gatepython.yml— ruff + pytest for the three Python packages, mypy for the base SDKshell.yml— shellcheck over every tracked shell scriptimages.yml— the single image entry point: on a push touchingboot/**,silkd/**, oros-image/**it builds the changed carriers (viabuild-boot.yml/build-silkd.yml,workflow_call) then os-images, in order, so the chain is deterministicbuild-os-images.yml— bakes base + flavors FROM the carriers, sha-pinned when rebuilt in the same runrelease.yml— on a version tag, checks the tag against silkd's version, then builds the release binaries and archivespublish-pypi.yml— on ansdk-*-v*tag, builds and publishes the matching package via PyPI Trusted Publishing (OIDC, per-package environment)
Boot chain
cloud-hypervisor
→ guest kernel (amd64: PVH ELF vmlinux, everything =y, no decompress stage; arm64: flat Image)
→ uncompressed ~1.5MB cpio: /init = sandbox-init (static Rust)
→ resolve virtio-blk serials via sysfs (2ms poll, no udev)
→ mount EROFS layers → overlayfs + ext4 COW → switch_root
→ exec /sbin/init (systemd, trimmed; cocoon-agent + silkd start at sysinit)
The cmdline keys sandbox-init consumes are in the
boot contract.
Development
make help # every target; the ones below are the daily set
make lint test # Rust: boot/init + silkd (fmt --check, clippy -D warnings, tests)
make go-lint # Go: protocol/wire + sandboxd + sdk/go + e2e + mcp, GOOS linux AND darwin
make go-test # Go: go test -race plus one pass of every benchmark, across the Go modules
make sh-lint # shellcheck every tracked shell script
make sandboxd # build dist/sandboxd
make bench # claim-tier + data-plane benchmarks; removes every sbx-* VM
make boot # kernel + initramfs artifact image (docker)
make silkd-image # silkd release binary in a scratch carrier image
make images # base + python images against the local boot + silkd images
License
The server stack — sandboxd, silkd, the boot chain, the OS images, and the
MCP server — is a product, and is licensed under AGPL-3.0. The client SDKs
(sdk/go, sdk/python, sdk/openai, sdk/langchain) and the
protocol/wire module the Go SDK requires are licensed under Apache-2.0
(see the LICENSE file in each directory) and carry no copyleft obligation.
Questions sur sandbox MCP
À quelle vitesse les sandboxes peuvent-elles démarrer ?
Un démarrage à froid (cold boot) prend environ 0,2 à 0,4 seconde sur du bare metal, tandis que les démarrages à chaud (warm claims) sont inférieurs à la milliseconde.
Quels langages sont pris en charge par le SDK ?
La sandbox propose des SDK pour Go et Python.
Que se passe-t-il si je lance sandboxd sur un nœud qui possède déjà des VM existantes ?
Au démarrage, sandboxd supprimera toutes les VM commençant par 'sbx-' dont il n'est pas le propriétaire.