On this page · 11 min
A cloud dev environment (CDE) is a development environment that runs on a machine in the cloud instead of on your laptop. Your code, toolchain and running processes live on that machine, and you connect to it from your editor, a terminal or a browser. Every developer gets the same setup, the laptop stops doing the heavy lifting, and the workspace is still there when you come back.
The four types at a glance
| Type | Example | Where it runs | Best for | Watch out for |
|---|---|---|---|---|
| Browser-based workspace | GitHub Codespaces | GitHub's cloud, in containers | Onboarding, open source, one standard toolchain | Running processes stop when the codespace stops (after 30 idle minutes by default) |
| Self-hosted platform | Coder | Your own infrastructure: Kubernetes, VMs or a cloud account | Orgs that need every workspace inside their own network | You operate the platform |
| Agent-era platform | Ona (formerly Gitpod) | The vendor's cloud, or your own cloud account on enterprise plans | Teams that want the agent and its environment from one vendor | OpenAI announced in June 2026 that it is buying Ona for Codex: check what is still sold on its own |
| Persistent VM over SSH | boxd | boxd cloud (Frankfurt or New York), or self-hosted in your Google Cloud or AWS account | Humans and agents sharing one workspace, long-running work | No built-in IDE: you bring your editor over SSH |
The rest of this guide covers how the category got here, what each type is good and bad at, what agents changed, and how to pick by team shape.
A short history before the present
The cloud dev environment was a 2020 idea that peaked around 2023, plateaued, and is now in an unexpected second wave. Browser-based IDEs didn't get much better in the meantime. What changed is that the AI agents everyone is building need somewhere to live, and that somewhere looks a lot like a CDE.
The category has three rough eras.
Era one: the browser editor (2020 to 2022). GitHub Codespaces, Gitpod, Replit. Open a repo in a browser tab, get a containerised dev environment with VS Code attached. The pitch was the right environment, instantly. It fit new contributors to open-source projects and organisations standardising tooling. It struggled for anyone whose workflow needed real disk persistence, GPUs, unusual tooling, or low latency.
Era two: the self-hosted plateau (2022 to 2024). Coder and Gitpod went hard on self-host. The category narrowed: most CDEs were either hosted SaaS we don't have to operate or self-host on our own infrastructure. Adoption was real but flat. The teams who needed it adopted; the teams who didn't kept their laptops.
Era three: agents arrive (2024 to now). Suddenly somewhere code can run that isn't my laptop matters in a different way. The agent needs a real Linux machine. It needs to run for hours. It needs to fork. It needs to keep state. The CDE primitive turns out to be most of what an agent execution environment is, and the platforms that bend toward agent workloads are pulling ahead of the ones still optimising for the human-in-the-IDE story.
What "cloud development environment" means in 2026
The term is messier than it should be. Cloud dev environment, cloud development environment, remote development, CDE, browser dev environment: they're used interchangeably and they mean different things. The minimal shared definition: a development environment whose compute runs somewhere other than your laptop.
Inside that, four types:
Type 1: Browser-based workspace
GitHub Codespaces is the canonical example. You open a repo, a container spins up in GitHub's cloud, and VS Code in the browser (or on your desktop) attaches to it. Everything's hosted, and everything is tied to the editor experience.
Where this fits: new-contributor onboarding, standardising tooling across an org, anyone who wants the lowest possible setup cost.
Where this struggles: anything that runs longer than a coding session. Files persist while a codespace is stopped, but running processes don't, and a codespace stops after 30 idle minutes by default. Low-latency access to services outside GitHub's cloud is also harder.
Type 2: Self-hosted platform
Coder is the clearest example. You run the platform on your own infrastructure, whether that's Kubernetes, plain VMs or a cloud account, and engineers get workspaces from templates you define. SSO, audit logs and network policies are all yours.
Where this fits: medium-to-large engineering orgs that want CDE benefits with self-host control. Compliance teams who need everything inside their own network.
Where this struggles: small teams without the ops capacity to run another platform. Workloads where containers are the wrong primitive (anything that wants kernel access, unusual device files, or long-lived process trees), unless you set up VM-based templates.
Type 3: CDE platforms repositioning around AI
The interesting recent moves are in this column. Gitpod renamed itself Ona in September 2025 and repositioned around software-engineering agents; in June 2026 OpenAI announced it would acquire Ona to run Codex agents inside customers' own clouds. A CDE company becoming an agent vendor's execution layer is the clearest sign yet of where the category is going. Coder has shipped agent-focused features on top of its self-host story. Daytona went the other direction, leaving the dev-environment category in early 2025 to position as an agent-sandbox product. Fly.io's Sprites was never a CDE in the first place; it's a persistent-microVM platform for code execution. Putting them side by side makes the point: the line between dev environment and agent runtime is dissolving fast.
Where this fits: teams that want the agent and the environment it runs in from one vendor.
Where this struggles: teams who want a settled product. The repositioning (and in Ona's case the acquisition) is real, and the docs aren't always caught up to where the product is.
Type 4: Persistent VM over SSH
boxd. Real VMs (KVM, not containers), persistent by default, forkable while they run, reached over SSH. The editor is whatever the developer prefers: VS Code or Cursor over Remote SSH, Zed, Claude Code in a terminal, vim. The agent reaches the same machine the same way.
Where this fits: teams whose work is a mix of human coding and agent execution, and who want one workspace for both. Teams who outgrew browser editors but don't want to run a platform on Kubernetes.
Where this struggles: teams whose dev environment story is VS Code in a browser tab and nothing else.
The four types overlap at the edges. What distinguishes them is what they optimise for: the editor experience (1), control over where workspaces run (2), the bet on agents (3), or one machine that holds both human and agent work (4).
What changed: agents joined the workload
For five years, the CDE category was about giving humans a better dev environment. In 2026 the workload is split. Some of the time the developer is in the workspace; some of the time an agent is. The platform either supports both or it picks one.
That shift turns five workspace properties that used to be nice-to-have into requirements:
- Persistent state across sessions. The agent does not stop at the end of the workday. The workspace can't either.
- Fast wake from sleep. The agent will be back in two hours. The workspace should be ready for it without being billed for those two hours.
- Fast fork from running state. Branch the workspace to run an experiment in parallel. Not a 30-second container build: a copy of the running machine in under 200 ms.
- A stable address. The agent receives webhooks, runs an MCP server, integrates with services that need to call back. The address has to stay the same.
- SSH-friendly by default. The agent talks SSH. The human can use whatever they want (IDE, browser, terminal). SSH is the lowest-common-denominator surface that locks neither of them in.
A container platform on Kubernetes can satisfy most of these with effort. Browser-only editors can't. The type that fits all five out of the box is the persistent VM, which is roughly what's pulling the category in that direction.
Where boxd fits
boxd is a cloud dev environment built for that split workload: a persistent Linux machine per developer and per agent. See development workspaces on boxd and coding agents on boxd for the two halves.
- A real VM per workspace. Every machine is a KVM virtual machine running Ubuntu 24.04, 2 vCPU, 8 GiB RAM and 100 GiB of disk by default. Files, installed tools and running processes survive between sessions.
- Sleeps when you step away. An idle machine hibernates and pays for its disk only. In our measurements a hibernated machine answered an HTTPS request with its app still running in 156 ms (median, measured 29 October 2026).
- An HTTPS URL for every machine. Webhooks land, previews work, MCP servers are reachable. Certificates are handled.
- Your editor, over SSH. VS Code and Cursor over Remote SSH, Zed, or a terminal. Claude Code, Codex and OpenCode come preinstalled for the agents.
- One setup for the whole team. Configure a machine once, snapshot it, and start every new machine from the snapshot.
- Fork in under 200 ms. Copy a running machine, memory and processes included, to try two approaches at once or hand a teammate an exact copy.
- Billed on use. Active vCPU only, memory in use and disk written, never the provisioned size. See pricing.
- Self-hostable. Free up to 16 vCPUs, on Google Cloud, AWS or bare metal. See self-hosting.
A working CDE on boxd looks like this:
boxd machine new dev # a persistent Linux VM
ssh dev.boxd # or open it in VS Code, Cursor or Zed over SSH
boxd snapshots save dev base # set it up once, start every new machine from it
boxd machine fork dev dev-experiment # copy the running machine, processes includedSame machine for the human, the agent and any branched experiment.
Picking by team shape
Indie developer. The free Codespaces quota or a small persistent VM both work. Pick on whether you need your processes to keep running between sessions and whether an agent in your loop needs continuity.
Small team building with agents. Persistent-VM platforms (boxd, Sprites) fit the workload better than browser editors. One machine per developer, plus one or more for the agents. Costs stay manageable because idle machines don't bill for compute.
Engineering org with mixed workloads. Self-host matters here, for cost control at scale and for compliance. Coder and self-hosted boxd both fit; pick on how much platform your ops team wants to run.
Regulated team or EU-data-bound org. Keep the workspaces in your jurisdiction: boxd's Frankfurt region runs on EU hardware, or self-host in your own cloud account in the region you choose. A smaller operational surface usually matters more than the platform choice itself.
What's next for the category
The CDE category is consolidating around persistence and agent-friendliness. The platforms that ship fast wake, fork from running state, and one workspace for both human and agent work will keep growing. The platforms still optimising for VS Code in a browser tab will stay useful for onboarding and standardisation and stop being interesting outside it.
The honest summary: a CDE in 2026 is not just a dev environment in the cloud. It's the machine that holds your engineers' work and your agents' work side by side. Pick one shaped for that.
That's what boxd is for. SSH in. It's yours. The agent can use it too. If you're comparing persistent-VM platforms, see boxd vs sprites.dev.
Last verified: 2026-11-10. This article is informational, not legal advice. Send corrections to hello@boxd.sh.
Frequently asked
- What is a cloud dev environment (CDE)?
- A development environment that runs on a machine in the cloud instead of on your laptop: your code, toolchain and running processes live there, and you connect from your editor, a terminal or a browser. In 2026 they come in four types: browser-based workspaces (GitHub Codespaces), self-hosted platforms (Coder), platforms turning into agent runtimes (Ona, formerly Gitpod) and persistent Linux VMs you reach over SSH (boxd).
- Is GitHub Codespaces still the best CDE in 2026?
- Best for new-contributor onboarding and standardising tooling at scale. Weaker for agent execution and anything that runs longer than a coding session: files persist while a codespace is stopped, but running processes don't, and a codespace stops after 30 idle minutes by default. The category has fragmented; pick by workload, not by brand.
- How do CDEs handle AI agents?
- Older CDEs (browser-IDE-first) treat the agent as another client connecting to the same workspace. Newer ones (persistent-VM-first) treat the agent and the human as peer occupants of the same machine — both connect over SSH, both read/write the same disk, both keep state across sessions. The second model fits longer agent loops better.
- Can I self-host a cloud dev environment?
- Yes. Coder runs on your own infrastructure (Kubernetes, VMs or a cloud account). boxd self-hosts for free up to 16 vCPUs in your own Google Cloud project or AWS account, with the same machines, forking, CLI and console as boxd cloud. Pick on how much platform your ops team wants to run.
- What's the difference between a CDE and an agent sandbox?
- A CDE is shaped for the human workflow (edit, run, test); an agent sandbox is shaped for short ephemeral execution (E2B-style). The line is blurring fast — agent workloads are pulling sandboxes toward persistence and pulling CDEs toward agent-friendliness. The persistent-VM substrate satisfies both, which is why the category is consolidating there.
- Will my CDE bill me when I'm not using it?
- Depends on the platform. Codespaces bills compute while a codespace runs and storage while it exists. boxd bills active vCPU only and memory in use while a machine runs, and a hibernated machine pays for its disk only.



