Website · Get started · Explainer · For agents · Deploy anywhere · Docs · Releases · Contribute
Differently is the open-source control plane for sandboxes. Install it on infrastructure you already run (any cloud, your own Kubernetes or bare metal), and your developers and agents get one sandbox API: create, exec, files, snapshots, fork. Differently decides where each sandbox runs and keeps account of it:
- by default on OpenSandbox on your own Docker hosts, Kubernetes clusters or microVM nodes;
- on Daytona or Freestyle, or a plugin for any other backend, only where your policies allow it;
- on 14 more provider adapters, from E2B and Vercel to the AWS, Azure and Google Cloud sandbox services, which are experimental: tested against fake servers and left out of the published build unless you compile them in.
Apache-2.0, fully self-hosted, no telemetry. Built by the OpenWork team.
Pre-release (
v0.1.0-alpha.7). The whole platform is implemented and tested end to end against real OpenSandbox servers (Docker, Kubernetes and Fast Sandbox microVM runtimes). It isn't ready for production workloads yet: see what is verified.
Teams adopting AI agents and automated code execution already run serious infrastructure, with their own IAM, networking and observability. Most sandbox products still ask them to add another vendor-run environment: another trust boundary, another API, another place where code, credentials and data end up.
Good open-source sandbox runtimes exist. Turning them into a multi-tenant platform is the hard part: quotas, fair queueing, deciding which runtime or provider each sandbox may use, and proving where work ran. Differently is that layer.
| One API, any backend | REST, CLI and SDKs for TypeScript, Python and Go. Applications never name a backend; operators change placement, code doesn't. |
| Policy decides where work runs | Private-first placement, data classifications, and external providers that are opt-in and fail-closed. |
| Multi-tenant from day one | Organizations, projects, scoped API keys with rotation, quotas and fair queueing. |
| Provable | A tamper-evident audit chain, a placement explanation for every sandbox, and an operator trust report. |
| Keys stay with you | Provider keys are stored sealed or by reference. Switch where new sandboxes go with one command. |
| Capacity that follows use | Paused microVMs give their pool slot back, resumes queue on a full pool, and preemption and run limits keep pools from filling up. |
| Self-hosted, all of it | API, dashboard and admin console, scheduler, queue, audit and metrics run on your infrastructure. No phone-home. |
Three commands, on macOS or Linux. No account, no cluster, no database.
curl -fsSL https://different-ai.github.io/differently/install.sh | sh # the CLI and the server, into ~/.local/bin
differently-server --dev # a local server; leave it running
differently run -- echo hello # in a second terminalrun creates a sandbox, runs the command in it and deletes it. Dev mode
keeps state in memory and runs commands on your machine with no
isolation: it is for learning the API, CLI and SDKs, not for code you do
not trust. The dashboard is at http://localhost:8080/dashboard/.
With a coding agent. Paste this into Claude Code, Codex, Cursor or any agent that can run commands:
Read https://different-ai.github.io/differently/agents.txt and follow it:
install Differently on this machine, start it in dev mode, run one sandbox to
prove it works, then show me how to create a sandbox from my code.
From your code (TypeScript, Python, Go). Against the local server the SDKs need no key and no project. They are not on npm or PyPI yet; each README says how to install from this repository.
import { Differently } from "@differently/sdk";
const differently = new Differently(); // or { baseUrl, apiKey } for a deployed server
const sandbox = await differently.sandboxes.create();
console.log((await sandbox.exec("uname -sm")).stdout);
await sandbox.delete();Then, when you want real isolation:
| Step up to | How | Time |
|---|---|---|
| The real stack on any Docker host | One file and docker compose up -d --wait: Postgres, Differently and an OpenSandbox server from published images |
about 5 minutes |
| A server for your team | One Linux VM on any cloud: k3s, OpenSandbox and Differently | about 30 minutes |
| Your Kubernetes cluster | The Helm chart and images from the latest release |
New here? Differently explained is the five-minute version of what it is and what you can ignore until later. The quickstart has the longer tour.
"Don't I need my snapshot on every provider?" Yes, and that is the one
thing nothing can do for you. Differently makes it one name: build the
baseline once per provider, register them as a template
(differently admin template set python --image POOL=IMAGE, on a running
server), and your code asks for the name. Requests go only to pools that have it, each backend gets its
own image, and differently templates and differently capabilities show
what every provider has and can do. A sandbox is placed once and stays put,
and so do its snapshots. See
one baseline on every provider and the other
questions people ask.
| Where | How | Status |
|---|---|---|
| Laptop | differently-server --dev |
Verified (no isolation; for trying it) |
| Any Docker host | One Compose file, published images | Verified in CI on every pull request: the file alone in an empty directory, started, one sandbox run. CI also runs the end-to-end suite on the same services |
| One Linux VM: Azure, AWS, Google Cloud, bare metal | k3s + Helm | Verified on Azure; same steps elsewhere, not yet run |
| Existing Kubernetes: EKS, GKE, AKS, k3s, RKE2 | Helm chart | Helm install verified on k3s; managed clusters documented |
| Cloud notes | AWS · Google Cloud · Azure · Bare metal | Documented |
| No internet | Air-gapped | Documented |
The deployment overview has the support matrix, prerequisites, day-2 operations and the hardening checklist.
Verified (2026-10-28 and 29):
- the end-to-end suite on OpenSandbox's Docker runtime, 14/14, and on its Kubernetes runtime (k3s on Azure, both installed with Helm), 14/14: every test it then had. CI now runs the suite on the Docker runtime on every pull request (results);
- on the Kubernetes runtime: stop/start keeping the disk, snapshots and fork through a snapshot registry, signed port URLs (including WebSockets) and egress policy;
- idle sandboxes stop (Kubernetes) or pause (Docker) and wake on the next call;
- the published
v0.1.0-alpha.1chart and images install from public artifacts alone; - real OpenSandbox responses are recorded and replayed in every
go test; - the experimental
agent-sandboxadapter against a Kubernetes cluster (kind); - the Daytona (container class) and Freestyle adapters against live accounts: exec, files, port URLs, stop/start and snapshots on both, and egress policy, pause/resume, memory snapshots and fork on Freestyle;
- OpenWork's Workbot computers run through Differently as a sandbox gateway, behind a flag, desktops on Fast Sandbox microVMs included, driven by OpenWork's runner;
- Fast Sandbox microVMs on Azure (two-node k3s with one KVM node): the adapter scenario (recorded), the end-to-end suite on the microVM pool (14 of the 18 tests it then had ran, and passed), and Workbot's desktop streamed over a port URL, paused and resumed with its memory, idled and woken by a request (pause takes minutes).
Not verified yet:
- any published release after
v0.1.0-alpha.1on a cluster: none is recorded as installed on one. The Kubernetes and Fast Sandbox runs above used pre-release code and have not been repeated since 2026-10-29; the changelog says what ran for each release; - node drains, and more than one KVM node;
- managed EKS, GKE and AKS;
- the other 12 provider adapters against live accounts: each is tested
against a fake of its provider's published API. These 12,
agent-sandboxandgroundboxare experimental and not in the published image or binaries; a server built with-tags experimental_adaptershas them (what the server contains).
Each of the 27 providers has a page with its tested status, capabilities and
configuration in the provider catalog. The
roadmap and feature parity
pages track the details. Releases follow semantic versioning:
pre-releases are tagged vX.Y.Z-alpha.N or -rc.N, and images are
ghcr.io/different-ai/differently-{server,cli}:X.Y.Z.
differently-server runs as stateless API replicas plus one elected scheduler
leader, with Postgres as its only dependency. Each request is admitted against
quota, queued fairly, then placed: the scheduler filters every registered pool
against global, organization and project policy, ranks what is left, and
records why. Adapters talk to the backends:
opensandbox, the default private runtime;daytonaandfreestyle, managed providers that receive work only when policy allows it;- 14 experimental adapters behind the
experimental_adaptersbuild tag, fromagent-sandboxandcubesandboxyou run toe2b,verceland the cloud providers' sandbox services (provider catalog); remote, any service speaking the adapter protocol.
Isolation and egress belong to each backend's runtime. Differently records what each pool declares and says so in the trust report.
Read the architecture and the security model.
Self-hosted sandbox runtimes exist (OpenSandbox, CubeSandbox, E2B's runtime). Differently builds on them rather than competing with them. What it adds is policy-driven placement across your own runtimes and external providers, under a control plane you run. See the feature parity matrix and the competitive landscape.
- Contribute: CONTRIBUTING.md covers the branch model
(PRs target
pre-release), DCO sign-off and releases. AGENTS.md is the entry point for coding agents and maintainers who change Differently; agents that install or use it start at docs/guides/agents.md. - Get help: SUPPORT.md.
- Report a vulnerability: SECURITY.md, privately.
- Conduct and decisions: CODE_OF_CONDUCT.md, GOVERNANCE.md.
Repository layout
| Path | What |
|---|---|
cmd/ |
differently-server and the differently CLI |
pkg/api, pkg/adapter, pkg/client |
Wire types, the versioned adapter contract and plugin protocol, the Go SDK |
internal/ |
Server, scheduler, reconciler, policy, store (memory and Postgres), auth, audit, secrets, adapters |
api/openapi.yaml |
The HTTP API contract (a test keeps it in sync with the router) |
sdk/typescript, sdk/python |
Official SDKs |
console/ |
The admin console: static files for any host, or Node with sign-in |
deploy/ |
Helm chart (control plane only), the Compose file for one Docker host, Terraform (AWS) |
docs/ |
Guides, deployment, architecture, security, roadmap |
site/ |
The website and docs site |
test/e2e, test/opensandbox |
The real-stack end-to-end suite and the live OpenSandbox checks |
