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, a GPU class with Nvidia and AMD cards, or macOS sandboxes in early access. It is built for teams that run agent code, code interpreters and evals through Python, TypeScript, Ruby, Go or Java SDKs.
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 who work on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config. It runs 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. “19th cheapest of 365” means 18 of the other 364 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 on its Linux VM class and ranks 19th. Codespaces is a compromise (290th): it has no browser built in, and GitHub does not publish how many codespaces can run at once. boat ranks 5th with Docker, /dev/kvm and a desktop on every sandbox. | 19th cheapest of 365 $4,111 a month | 290th of 365, with limits $4,618 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Daytona sandboxes can run with no time limit and rank 31st. A codespace stops after 12 hours at most and after 30 idle minutes by default, so it is a compromise (320th). boat ranks 6th, with auto-stop off on a paid plan (default 1 hour). | 31st cheapest of 361 $6,104 a month | 320th of 361, with limits $6,970 a month | 6th cheapest of 361 $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 and ranks 31st: it creates hundreds of sandboxes a minute with no plan fee. Each codespace builds a dev container on a new VM (283rd, compromise). boat's start limits make big bursts a compromise too (189th). | 31st cheapest of 336 $271 a month | 283rd of 336, with limits $619 a month | 189th of 336, 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 (153rd), and GitHub does not publish how many codespaces can run at once (276th). boat ranks 3rd. | 153rd of 349, with limits $2,000 a month | 276th of 349, with limits $1,964 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 134th of 349, with limits $8,261 a month | 276th of 349, with limits $9,489 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 192nd of 359, with limits $2,000 a month | 295th of 359, with limits $1,519 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 309th of 374, with limits $805 a month | 317th of 374, with limits $909 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces is a polished VS Code box per repository (144th): on a GitHub Free account it stops every 12 hours. Daytona needs a $500 top-up for open internet and bills the disk while stopped (200th). boat ranks 19th and runs until you stop it once auto-stop is off. | 200th of 371, with limits $245 a month | 144th of 371, with limits $270 a month | 19th cheapest of 371 $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 (29th). A codespace can add a basic noVNC desktop through the desktop-lite dev container feature, which you set up, with no computer-use API (297th). boat ranks 7th with a 60 fps desktop built in. | 29th cheapest of 367 $1,198 a month | 297th of 367, with limits $1,367 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 114th of 356, with limits $598 a month | 306th of 356, with limits $678 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 42nd cheapest of 343 $404 a month | 324th of 343, with limits $922 a month | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 203rd of 327, with limits $8,073 a month | 279th of 327, with limits $18,637 a month | 73rd of 327, 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 fork a sandbox with its memory (18th), and boat forks a running sandbox (3rd). On Codespaces every copy is created again from the repository or a prebuild (284th). | 18th cheapest of 351 $2,000 a month | 284th of 351, with limits $445 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Daytona fits (19th): it rents Nvidia and AMD GPUs by the hour. Neither Codespaces nor boat has GPUs. | 19th cheapest of 102 $1,190 a month | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
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 with its own namespaces by default; Linux VM and Windows VM classes with a hardware virtualization boundary | A Docker container on its own newly built VM, with its own virtual network | Every sandbox is a full VM with its own kernel; vCPUs are shared |
| How long it runs | No time limit by default; auto-stop can be turned off | Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use | Auto-stop after 1 hour by default; up to 30 days, or off on a paid plan with no session cap |
| CPU speed (V8 Web Tooling Benchmark, 4 vCPU / 8 GB, StarSling run of 3 October 2026) | 21.52 runs/s on the Linux VM class (shared rank 2); the default container class has no result | Not in the public benchmarks we use | 28.06 runs/s, second of 15 (shared rank 2), on an AMD Ryzen 9 9950X host |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker inside the dev container through a dev container feature, with sudo; /dev/kvm is not documented | Docker, root, systemd and /dev/kvm on every sandbox |
| Desktop and computer use | VNC desktop and a computer-use API on Linux and Windows | VS Code, JupyterLab and a terminal; a Fluxbox desktop over noVNC through the desktop-lite feature, which you configure; no computer-use API | 1920x1080, 60 fps desktop and Chrome, computer tools for agents, embeddable stream |
| Files after a stop | Whole disk kept and billed while stopped; containers auto-archive after 7 days stopped (free) | Files are kept and storage is billed; a stopped codespace is deleted after 30 days by default | Disk saved every minute and at each stop; no compute charge while stopped; kept at least 14 days, longer with a saved snapshot |
| Pause and fork | Linux VM and Windows classes pause, resume and fork with memory kept; containers start new sandboxes from filesystem snapshots | No copy or snapshot endpoint; each codespace starts from a repo, branch, pull request or prebuild | Fork a running sandbox from its last 1-minute snapshot; 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 | boat's image or a saved snapshot; you cannot boot your own Docker or OCI image |
| Coding agents | You set it up: guides to install agents and run them through process exec | GitHub Copilot as a VS Code extension; other agents you install yourself | Seven harnesses 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 | Optional AI credentials proxy ($1 a day plus $1 per 1,000 requests); other secrets still enter the sandbox |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no public IP | A URL per forwarded port, private, organization or public; SSH; no public IP | Up to 50 HTTPS URLs, token-gated by default; SSH; a public IPv6 address, and raw ports over IPv4 only on sandboxes with their own 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 (firewall rules inside the VM) |
| 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; Germany, Finland and France, no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Daytona | GitHub Codespaces | boat |
|---|---|---|---|
| Full VM (own kernel) | No documented way | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Not published | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | With your own setup | Yes |
| Browser | Yes | No documented way | Yes |
| Computer-use API | Yes | No documented way | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No documented way | Yes |
| Fork/clone | Yes | No documented way | Yes |
| Live fork (no pause) | No documented way | No documented way | Yes |
| Memory fork | Yes | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No documented way | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | No documented way | No documented way | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | No documented way | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | No documented way | No documented way |
| Secret proxy | Yes | No documented way | Yes |
| Secret proxy for any API | Yes | No documented way | Yes |
| Preinstalled agents | Yes | No documented way | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | No documented way | No documented way |
| GPU | Yes | No documented way | No documented way |
| Windows | Yes | No documented way | No documented way |
| Arm64 | No documented way | No documented way | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | Yes | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No documented way | Yes |
| Audit logs | Yes | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | No documented way | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
GitHub Codespaces is not in the public benchmarks we use, so we cannot say how it compares. In StarSling's run of 3 October 2026 (run 37073680030), the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, boat did 28.06 runs/s (second of 15) and Daytona's Linux VM class 21.52. Both share rank 2, so the run cannot separate them. Daytona's default container class has no result in that run. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host; boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Providers ran on different hardware in different regions.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. GitHub Codespaces is not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| 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 | $8,800 · $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 with no plan fee and $200 of free compute: 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, used or not, 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: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07.
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 Tiers 1 and 2 reach only an allowlist of services. GitHub Codespaces stops every codespace at 12 hours, so the always-on scenario needs a restart script, and GitHub 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: the 1,000-job burst needs about 6,667 starts a day against 2,400 included on the $2,000 plan, and starts above 270 a minute fail with 429.
| Scenario | Daytona | GitHub Codespaces | boat |
|---|---|---|---|
| One coding agent, workdays |
| None for this scenario | None for this scenario |
| One agent that never stops |
|
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 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, and it keeps its disk after a stop. Daytona gives /dev/kvm on its VM class, and a codespace stops every 12 hours at most.
A full VM on every sandbox
On Daytona the default is a container with its own namespaces, and /dev/kvm needs the VM class plus KVM turned on for your organization. Codespaces does not document /dev/kvm, so plan Android emulators and microVMs elsewhere.
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 whole disk while stopped. boat saves the disk every minute; a stopped sandbox has no compute charge and keeps its disk at least 14 days.
Agents you drive from outside
On both, you install the agent and write the code that starts and watches it. Codespaces copies keys in as environment variables. boat ships Claude Code, Codex and five other harnesses with a prompt API, and its optional paid proxy keeps supported providers' keys outside.
Use boat when your agents work for hours or days: full VMs with /dev/kvm, a desktop and public HTTPS URLs, coding agents built in, and sandboxes that keep their disk and fork while running. Compare it one to one: boat vs Daytona and boat vs GitHub Codespaces.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
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. 50 agents in parallel come to $2,682 on Daytona against $3,019. boat comes to $20 and $317 for the same two scenarios. Below about $20 of use a month, the free Codespaces quota on a personal account costs less.
Which is faster, Daytona or GitHub Codespaces?
Codespaces is not in the public benchmarks we use, so we cannot say. In StarSling's run of 3 October 2026 at 4 vCPU / 8 GB, Daytona's Linux VM class did 21.52 runs/s and boat 28.06; the run cannot separate them.
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 auto-stop can be turned off. A codespace stops after 12 hours at most, even while in use, so it needs a restart script. On boat, auto-stop defaults to 1 hour; turn it off on a paid plan and the 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 through a dev container feature. Daytona's Linux VM class offers /dev/kvm once KVM is turned on for your organization; Codespaces does not document it. Every boat sandbox 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; you can add a basic noVNC desktop with the desktop-lite feature, with no computer-use API. boat has no GPUs, and streams a 60 fps desktop with Chrome.
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 in Germany, Finland and France, you cannot pick a region, and snapshot copies can be stored outside the EU.
Try boat
Install the CLI, then run boat new.
7-day free trial