Gitpod's docs don't open with a product tour anymore. They open with a line I had to read twice: new customer signup is closed, and the way in is "get started with Codex". The company that taught a lot of us what a cloud dev environment is has stopped selling environments to people. It's Ona now, and it sells a place for background agents to run.
One company changing its mind is a press release. I read the docs of 25 projects in this space in one sitting, from bubblewrap to Cloudflare Sandboxes, and the shift is across the whole layer: the customer changed. Most maps of "dev environments" are out of date, including mine.
Four layers, and why the arguments never resolve
| Layer | Question it answers | Examples |
|---|---|---|
| 1. Kernel isolation | How do we stop the process? | namespaces, seccomp, gVisor, Firecracker |
| 2. Runtimes and images | How do we ship a filesystem and entrypoint? | Docker, Podman, Kata, OCI |
| 3. Declaration | How do we say what a project needs? | Nix, devcontainers, mise, uv |
| 4. Hosted environments | Who runs it for us, per session? | Codespaces, Coder, Daytona, E2B |
A layer-4 tool solves nothing about layer 1. A layer-3 tool assumes somebody already solved 1 and 2. Daytona booting a sandbox in 90ms says nothing about whether your Postgres is reachable.
What actually got solved
Tool versions. mise collapses asdf, direnv and a chunk of make into one mise.toml. uv replaced pyenv, poetry and tox for me in an afternoon. Pixi covers the conda side where native libraries matter; Hermit's committed shims give clone-and-run onboarding with no install step.
Hermetic builds. Nix is still the only thing that is genuinely reproducible and hermetic, and flake.lock pinning the input graph is the part that matters. devenv, Devbox and Flox are front doors to the same store.
What didn't
Services and system libraries. Every layer-3 tool either punts to Docker or grows a process manager. devenv is the honest one — devenv.nix declares Postgres and Redis with lifecycle management. Everyone else declares versions and hopes you already have libpq.
Trust in downloads. A declaration that can name a URL is a declaration that can be edited in a drive-by PR. That's where most supply-chain hand-waving lives.
The pivot, with receipts
- Ona (was Gitpod): signup closed, docs point at Codex.
- Daytona: dev environments to "sandboxes for AI-generated code" — own kernel, OCI-compatible, sub-90ms start claimed.
- Dagger: "third-generation CI, after Jenkins and GitHub Actions… built to match the speed of coding agents."
- Earthly: the build tool became Earthly Lunar, "engineering guardrails for the AI era".
Three of those are one move. The fourth is the same move with a sadder ending. Claimed numbers are the vendor's; I benchmarked nothing.
What I did with it
The project I'm building runs repos on a host it doesn't own, so the environment is an input, not scenery:
-
env-checkanswers whether a repo's declared environment is present and intact;env-initbuilds it, printing the plan unless--applyis passed. Neither is a pipeline step — a pipeline that installs a toolchain is a pipeline that changes the host. - The store is keyed by digest (
envs/<digest>/withenv.json,bin,lib), built in a temporary sibling and renamed on success, so a failed init leaves nothingenv-checkcould accept. - Missing environment is exit 6, not exit 3. A caller that sees 3 changes the subject; a caller that sees 6 tells a person to run
env-init. - What may be downloaded is the runner's list, not the declaration's: one pinned URL and checksum per toolchain. A declaration chooses a version, never a source.
The environment a child gets is also part of the cage — more boring than isolation, but the part that bites first:
var envPassthrough = []string{"PATH", "LANG", "LC_ALL", "TZ"} func Env(runDir string, creds Credentials) ([]string, error) { if creds.Name == "" || creds.Email == "" { return nil, refused("env: no git identity; a child that cannot commit is not a build run") } tmp, home := filepath.Join(runDir, "tmp"), filepath.Join(runDir, "home") for _, dir := range []string{tmp, home} { if err := ensurePrivate(dir); err != nil { return nil, err } } env := make([]string, 0, 16) for _, name := range envPassthrough { if v, ok := os.LookupEnv(name); ok && v != "" { env = append(env, name+"="+v) } } env = append(env, "HOME="+home, "TMPDIR="+tmp, "GIT_CONFIG_NOSYSTEM=1", "GIT_TERMINAL_PROMPT=0") // ... } A child that inherits the parent's environment can read every credential on the box; one that inherits its TMPDIR writes outside the run. Allowlist, scratch inside the run, no system gitconfig, a refusal when there's no identity to commit under.
The question that's left
It isn't which environment tool. It's who owns the environment when the person who wrote the code is not the person who ran it. A host running someone else's code has to name the environment the way it names the branch and the base sha — and say no at the front door instead of discovering half a toolchain at the gate and calling it a failing test.
The layer-4 companies already know this. That's why they stopped selling to humans.




