Daytona vs GitHub Codespaces
Daytona is a cloud you drive from code: you create sandboxes through its API and SDKs, as containers by default or as Linux VM, Windows or GPU classes. GitHub Codespaces is a dev environment for people: a dev container on its own VM, opened from a repository in VS Code or the browser, that stops after 12 hours at most.
The companies and products
Daytona
Daytona is a cloud for running AI-generated code: you create sandboxes from code through its API and SDKs.
By default a Daytona sandbox is a Linux container with its own namespaces and reserved vCPU, memory and disk. You can also pick a Linux VM class (pause, fork, memory snapshots, /dev/kvm), a Windows VM class, or a GPU class with Nvidia and AMD cards. It is built for teams that run agent code, code interpreters and evals through Python, TypeScript, Ruby, Go or Java SDKs.
- Founded
- 2023
GitHub Codespaces
GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.
Codespaces is a different kind of product from boat: a dev environment for people working on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config, running on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “15th cheapest of 367” means 14 of the other 366 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Daytona: price rank | GitHub Codespaces: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits a software factory once you pick its Linux VM class for /dev/kvm, while Codespaces is a compromise because every codespace stops at 12 hours; boat has Docker and /dev/kvm on every machine. | 15th cheapest of 367 $4,111 a month | 274th of 367, with limits $4,618 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Daytona sandboxes can run with no time limit, while a codespace stops after 12 hours at most and after 30 idle minutes by default, so an always-on assistant fits Daytona and boat far better. | 24th cheapest of 366 $6,104 a month | 309th of 366, with limits $6,970 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Daytona fits short code runs: it creates hundreds of sandboxes a minute with no plan fee, while each codespace builds a dev container on a new VM. | 25th cheapest of 345 $271 a month | 288th of 345, with limits $619 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Neither fits 300 sandboxes at once out of the box: Daytona's Tier 4 pool stops at 500 vCPU, and GitHub does not publish how many codespaces can run at once. | 154th of 361, with limits $2,000 a month | 281st of 361, with limits $1,964 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 130th of 360, with limits $8,261 a month | 282nd of 360, with limits $9,489 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 189th of 364, with limits $2,000 a month | 295th of 364, with limits $1,519 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 308th of 377, with limits $805 a month | 314th of 377, with limits $909 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces is the more polished VS Code box for one repository, but it stops every 12 hours, and Daytona keeps billing the disk while a sandbox is stopped; boat runs until you stop it. | 183rd of 368, with limits $245 a month | 130th of 368, with limits $270 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Daytona has a VNC desktop and a computer-use API on Linux and Windows, while a codespace has an editor and a terminal but no graphical desktop; boat streams a 60fps desktop. | 26th cheapest of 369 $1,198 a month | 267th of 369, with limits $1,367 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 93rd of 367, with limits $598 a month | 275th of 367, with limits $678 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 38th cheapest of 346 $404 a month | 310th of 346, with limits $922 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 202nd of 338, with limits $8,073 a month | 280th of 338, with limits $18,637 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Daytona's VM classes can fork a sandbox with its memory, and boat forks a running sandbox, while on Codespaces every copy is created again from the repository. | 12th cheapest of 360 $2,000 a month | 267th of 360, with limits $445 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Daytona fits: it rents Nvidia and AMD GPUs by the hour, and neither Codespaces nor boat has GPUs. | 20th cheapest of 98 $1,190 a month | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Daytona | GitHub Codespaces | boat |
|---|---|---|---|
| What it is | A sandbox API and SDKs for running AI-generated code | A cloud dev environment for a GitHub repository, opened in VS Code or the browser | A sandbox API for agents: full VMs you create, fork and drive from code |
| Isolation | Container by default; Linux VM and Windows VM classes on request | A Docker container on its own newly built VM, with its own virtual network | Every sandbox is a full VM with its own kernel |
| How long it runs | No time limit by default; idle auto-stop can be turned off | Stops after 30 idle minutes by default and after 12 hours at most, even while in use | Runs until you stop it; no session cap on paid plans |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.52 runs/s on the Linux VM class; the default container class reported no result | Not measured | 26.69 runs/s |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker and sudo inside the dev container; /dev/kvm is not documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | VNC desktop and a computer-use API on Linux and Windows | VS Code, JupyterLab and a terminal; no graphical desktop | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Files after a stop | The disk is kept and billed while stopped; archived containers are free | Files are kept and storage is billed; stopped codespaces are deleted after 30 days by default | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Pause and fork | Linux VM and Windows classes pause, resume and fork with memory kept; containers do not | No copy or snapshot endpoint; each codespace starts from a repo, branch, pull request or prebuild | Fork a running sandbox into copies; resume reboots from disk |
| Starting point | Docker images and declarative builds for containers; VM snapshots from an image | Dev container config in the repository, with prebuilds built by GitHub Actions | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Coding agents | Guides to install agents and run them through process exec | GitHub Copilot as a VS Code extension; other agents you install yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Secrets are copied into the codespace as environment variables | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | A URL per forwarded port, private, organization or public; SSH; no public IP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Outbound internet | Tier 1 and 2 reach only registries, git hosts and AI APIs; Tier 3 and up get open internet with per-sandbox allowlists | Open internet; GitHub says there is no way to restrict it | Open internet on every plan; no provider-side allowlist |
| GPUs, Windows and regions | Nvidia and AMD GPUs, Windows VMs; US and EU regions, or your own machines | Linux only, no GPUs; US East, US West, Europe West and Southeast Asia | Linux only, no GPUs; EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | GitHub Codespaces | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | No | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public run of 2026-09-29 at 4 vCPU / 8 GB, boat did 26.69 Node.js build-and-test runs per second and Daytona's Linux VM class did 21.52. Daytona's default container class reported no result in that run. GitHub Codespaces was not in the benchmark, so there is no comparable number for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). GitHub Codespaces has no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Daytona, a month | GitHub Codespaces, a month | boat, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $56 · Tier 3 ($500 top-up) | $51 · Personal account: GitHub Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $245 · Tier 3 ($500 top-up) | $270 · Personal account: GitHub Free · with limits | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $2,682 · Tier 3 ($500 top-up) | $3,019 · Personal account: GitHub Free | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $850 · Personal account: GitHub Free · with limits | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $1,889 · Personal account: GitHub Free · with limits | $2,000 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, and keeps billing the disk while a sandbox is stopped. You pay from a prepaid wallet: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, plus $0.07 per GB-month of storage while it exists, stopped too. There is no 4-core machine with 8 GB, so a 4 vCPU / 8 GB job is priced on the 4-core 16 GB machine; personal accounts get a free monthly quota and organizations do not.
GitHub Codespaces: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Daytona limits the total vCPU running at once, up to 500 vCPU on Tier 4, so 300 user sandboxes (600 vCPU) and 1,000 short jobs (2,000 vCPU) need a custom limit, and Tier 1 and 2 reach only an allowlist of services. GitHub Codespaces stops every codespace at 12 hours, so it does not fit the always-on scenario, and it does not publish how many codespaces can run at once, so 300 or 1,000 at once are not confirmed. On boat the limit is a sandbox count plus starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Daytona | GitHub Codespaces | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Daytona when
your code creates sandboxes through an API and you need GPUs, Windows, memory pause, network allowlists, or US regions and your own machines.
- Built for code, not people. Useful if your own code starts the sandboxes: Daytona has SDKs in five languages and no 12-hour stop.
- GPUs and Windows. Useful if your agents test models or need Windows desktops: Daytona rents GPUs by the hour and runs Windows VMs.
- Pause with memory, and network rules. Useful if a sandbox must resume exactly where it was, or reach only chosen domains: Daytona's VM classes and Tier 3 do both.
Use GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, for sessions under 12 hours.
- Built into GitHub. Useful if your team lives on GitHub: open a ready codespace from any repo, branch or pull request.
- Free hours for personal accounts. Useful for occasional personal work: a GitHub Free account includes 120 core-hours and 15 GB-month of storage each month.
- Regions in the US and Asia. Useful if your developers sit in the US or Asia: codespaces run in US East, US West, Europe West and Southeast Asia.
Where boat fits
If what you are really running is coding agents that work for hours, look at boat. Every boat sandbox is a full VM with Docker and /dev/kvm, a desktop and agents built in, that runs until you stop it and keeps its work. Daytona gets there only on its VM class, and Codespaces stops every 12 hours.
A full VM on every machine
On Daytona the default is a container that shares the host kernel, and /dev/kvm needs the VM class plus KVM turned on for your organization. Codespaces documents no /dev/kvm at all, so emulators and microVMs have nowhere to run.
Long work that keeps going
A codespace stops at 12 hours even while the agent works, and its processes end, so you write a restart script. Daytona has no cap but bills the disk while stopped; boat saves the disk every minute and a stopped sandbox is free.
Agents you drive from outside, keys kept out
On both, you install the agent and write the code that starts and watches it. Codespaces copies keys in as environment variables any code can read; boat ships Claude Code and Codex with a prompt API and keeps keys in a proxy.
Use boat when your agents work for hours or days: full VMs with /dev/kvm, a desktop and open ports, coding agents built in with keys kept outside, and machines that keep their work and fork while running. Compare it one to one: boat vs Daytona and boat vs GitHub Codespaces.
Questions people ask
Is Daytona cheaper than GitHub Codespaces?
It depends on the job. One coding agent on workdays is $56 a month on Daytona and $51 on Codespaces, while 50 agents in parallel come to $2,682 on Daytona against $3,019. boat comes to $20 a month and $317 for the same two scenarios.
Which is faster, Daytona or GitHub Codespaces?
There is no comparable number for Codespaces, since it was not in the public benchmark. In that run, Daytona's Linux VM class did 21.52 Node.js build-and-test runs per second and boat did 26.69, at 4 vCPU / 8 GB.
Can I run an AI agent 24/7 on Daytona or Codespaces?
On Daytona, yes: a sandbox has no time limit unless you set one, and idle auto-stop can be turned off. A codespace stops after 12 hours at most, even while in use, so it needs a restart script. A boat sandbox runs until you stop it.
Can Daytona and Codespaces run Docker?
Both run Docker: Daytona in all its sandbox classes, Codespaces inside the dev container with sudo. Only Daytona's Linux VM class offers /dev/kvm, once KVM is turned on for your organization, and Codespaces does not document it. Every boat machine has Docker, systemd and /dev/kvm.
Do Daytona or Codespaces have GPUs or a desktop?
Daytona rents Nvidia and AMD GPUs and has a VNC desktop with a computer-use API on Linux and Windows. Codespaces has no GPUs and no graphical desktop, only an editor and a terminal. boat has no GPUs, and streams a 60fps desktop with Chromium.
Where do Daytona and Codespaces run?
Daytona runs in the US and the EU, and can run on your own machines. Codespaces runs in US East, US West, Europe West and Southeast Asia. boat runs only in the EU, in Germany, Finland and France.
Try boat
Install the CLI, then run boat new.
7-day free trial