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.

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 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 workloadDaytona: price rankGitHub Codespaces: price rankboat: 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 requirementNot 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 requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureDaytonaGitHub Codespacesboat
What it isA sandbox API and SDKs for running AI-generated codeA cloud dev environment for a GitHub repository, opened in VS Code or the browserA sandbox API for agents: full VMs you create, fork and drive from code
IsolationContainer with its own namespaces by default; Linux VM and Windows VM classes with a hardware virtualization boundaryA Docker container on its own newly built VM, with its own virtual networkEvery sandbox is a full VM with its own kernel; vCPUs are shared
How long it runsNo time limit by default; auto-stop can be turned offStops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in useAuto-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 resultNot in the public benchmarks we use28.06 runs/s, second of 15 (shared rank 2), on an AMD Ryzen 9 9950X host
Docker and nested virtualizationDocker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organizationDocker inside the dev container through a dev container feature, with sudo; /dev/kvm is not documentedDocker, root, systemd and /dev/kvm on every sandbox
Desktop and computer useVNC desktop and a computer-use API on Linux and WindowsVS Code, JupyterLab and a terminal; a Fluxbox desktop over noVNC through the desktop-lite feature, which you configure; no computer-use API1920x1080, 60 fps desktop and Chrome, computer tools for agents, embeddable stream
Files after a stopWhole 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 defaultDisk saved every minute and at each stop; no compute charge while stopped; kept at least 14 days, longer with a saved snapshot
Pause and forkLinux VM and Windows classes pause, resume and fork with memory kept; containers start new sandboxes from filesystem snapshotsNo copy or snapshot endpoint; each codespace starts from a repo, branch, pull request or prebuildFork a running sandbox from its last 1-minute snapshot; resume reboots from disk
Starting pointDocker images and declarative builds for containers; VM snapshots from an imageDev container config in the repository, with prebuilds built by GitHub Actionsboat's image or a saved snapshot; you cannot boot your own Docker or OCI image
Coding agentsYou set it up: guides to install agents and run them through process execGitHub Copilot as a VS Code extension; other agents you install yourselfSeven harnesses preinstalled, with a prompt, steer and events API
Keeping keys out of the sandboxSecrets proxy swaps placeholders in HTTPS request headers for allowed hostsSecrets are copied into the codespace as environment variablesOptional AI credentials proxy ($1 a day plus $1 per 1,000 requests); other secrets still enter the sandbox
Reaching the sandboxHTTPS preview URLs on any port, token-protected or public; SSH; no public IPA URL per forwarded port, private, organization or public; SSH; no public IPUp 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 internetTier 1 and 2 reach only registries, git hosts and AI APIs; Tier 3 and up get open internet with per-sandbox allowlistsOpen internet; GitHub says there is no way to restrict itOpen internet on every plan; no provider-side allowlist (firewall rules inside the VM)
GPUs, Windows and regionsNvidia and AMD GPUs, Windows VMs; US and EU regions, or your own machinesLinux only, no GPUs; US East, US West, Europe West and Southeast AsiaLinux only, no GPUs; Germany, Finland and France, no US or Asia region
Every feature Battleships tracks (43)
FeatureDaytonaGitHub Codespacesboat
Full VM (own kernel)No documented wayYesYes
Docker insideYesYesYes
Nested virtualizationYesNot publishedYes
RootYesYesYes
SystemdNot publishedNot publishedYes
Desktop GUIYesWith your own setupYes
BrowserYesNo documented wayYes
Computer-use APIYesNo documented wayYes
SSHYesYesYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneYesNo documented wayYes
Live fork (no pause)No documented wayNo documented wayYes
Memory forkYesNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesNo documented wayYes
Idle auto-stopYesYesNo documented way
Wake on requestNo documented wayNo documented wayNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesNo documented wayNo documented way
Secret proxyYesNo documented wayYes
Secret proxy for any APIYesNo documented wayYes
Preinstalled agentsYesNo documented wayYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesNo documented wayNo documented way
GPUYesNo documented wayNo documented way
WindowsYesNo documented wayNo documented way
Arm64No documented wayNo documented wayNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCYesNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysYesNot publishedYes
Spend limitsNot publishedYesYes
Usage per sandbox (API)YesNo documented wayYes
Audit logsYesYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesNo documented wayNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Daytona21.52 runs/s
GitHub CodespacesNot measured
boat28.06 runs/s

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.

ScenarioDaytona, a monthGitHub Codespaces, a monthboat, 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.

ScenarioDaytonaGitHub Codespacesboat
One coding agent, workdays
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
None for this scenarioNone for this scenario
One agent that never stops
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
  • Personal account: GitHub Free: sessions capped at 12 h
None for this scenario
50 agents in parallel
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
None for this scenario
Sandboxes for your users
  • max 500 vCPU running at once (needs 600)
  • max 1,000 GiB running at once (needs 1,200)
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
None for this scenario
1,000 short jobs at once
  • max 500 vCPU running at once (needs 2,000)
  • max 1,000 GiB running at once (needs 4,000)
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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

More comparisons