Skip to content

About

Open-source, self-hosted control plane for sandboxes: one API, tenancy, quotas and policy-gated placement across OpenSandbox, 15 more provider adapters (E2B, Daytona, Vercel, AWS, Azure, Google Cloud…) or your own backend.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

9 stars

Watchers

0 watching

Forks

Differently: your apps and agents call one API; differently-server handles tenancy, quotas, policy and audit, and places each sandbox on OpenSandbox or your own backend inside your infrastructure, or on a managed provider such as Daytona or Freestyle only if policy allows

Latest release CI on pre-release License: Apache-2.0 Go 1.26 Documentation

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.

Watch: Differently in 36 seconds
▶ Watch the 36-second intro

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.

Why

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.

Get started

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 terminal

run 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.

Deploy anywhere

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.

Status

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.1 chart and images install from public artifacts alone;
  • real OpenSandbox responses are recorded and replayed in every go test;
  • the experimental agent-sandbox adapter 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.1 on 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-sandbox and groundbox are experimental and not in the published image or binaries; a server built with -tags experimental_adapters has 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.

How it works

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;
  • daytona and freestyle, managed providers that receive work only when policy allows it;
  • 14 experimental adapters behind the experimental_adapters build tag, from agent-sandbox and cubesandbox you run to e2b, vercel and 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.

How it compares

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.

Community

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

License

Apache License 2.0.

About

Open-source, self-hosted control plane for sandboxes: one API, tenancy, quotas and policy-gated placement across OpenSandbox, 15 more provider adapters (E2B, Daytona, Vercel, AWS, Azure, Google Cloud…) or your own backend.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

9 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages