Daytona vs Namespace

Daytona is a cloud for running AI-generated code: containers by default, with Linux VM, Windows and GPU classes, and no default time limit. Namespace is mainly a CI and build platform. Its Devboxes are remote Linux and macOS machines for people and coding agents, and they stop after 3, 5 or 24 hours by plan.

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

Namespace

Namespace is a dev platform for fast builds, tests and coding environments: CI runners, build caches and Devboxes, on its own hardware.

Most of Namespace is CI: a faster drop-in for GitHub Actions runners, with Docker, Bazel, Turborepo and Nix caching. Its Devboxes are remote Linux and macOS machines with persistent storage, made for people and AI coding agents. You run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions, and Namespace also hosts sessions for Claude Managed Agents, Cursor Cloud Agents, Devin and Amp. It is a different kind of product from boat, so this page compares the part where they overlap: a machine an agent works on.

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 rankNamespace: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
19th cheapest of 365
$4,111 a month
74th of 365, with limits
$3,745 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
Daytona fits because a sandbox can run with no deadline (31st). A Namespace Devbox stops at its plan's limit even while it works, so your code restarts it (316th, compromise). boat ranks 6th, with auto-stop off on a paid plan.
31st cheapest of 361
$6,104 a month
316th of 361, with limits
$6,645 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 one-minute runs well (31st), creating hundreds of sandboxes a minute with no plan fee. Namespace caps Devboxes at 50 per workspace (244th), and boat's start limits make big bursts a compromise (189th).
31st cheapest of 336
$271 a month
244th of 336, with limits
$250 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
All need more room: 300 sandboxes of 2 vCPU need 600 vCPU, more than Daytona's Tier 4 pool of 500 (153rd), and Namespace caps Devboxes at 50 per workspace (279th). boat ranks 3rd.
153rd of 349, with limits
$2,000 a month
279th of 349, with limits
$2,068 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
345th of 349, with limits
$9,012 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
282nd of 359, with limits
$1,093 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
Namespace fits (87th): CI runners with Docker, Bazel and Turborepo caches are its main product. Daytona caps a sandbox at 4 vCPU by default (309th, compromise). boat ranks 2nd and runs CI jobs on full VMs, but sells no managed runner.
309th of 374, with limits
$805 a month
87th cheapest of 374
$765 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
Both are a compromise here: a Namespace Devbox stops when idle and wakes when you connect but stops at its plan's limit (201st), and Daytona needs a $500 top-up for open internet (200th). boat ranks 19th and stays up once auto-stop is off.
200th of 371, with limits
$245 a month
201st of 371, with limits
$250 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 fits with a VNC desktop and a computer-use API on Linux and Windows (29th). Namespace's screenshot and click API works on macOS Devboxes; on a Linux Devbox you install a desktop and VNC in your image (108th). boat ranks 7th with a 60 fps Linux desktop.
29th cheapest of 367
$1,198 a month
108th of 367, with limits
$1,032 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
191st of 356, with limits
$789 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
191st of 343, with limits
$332 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
225th of 327, with limits
$9,012 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
18th cheapest of 351
$2,000 a month
112th of 351, with limits
$339 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. Namespace and boat are CPU only.
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
Only Namespace fits (6th): it runs macOS Devboxes and instances on Apple Silicon. boat has no macOS, and Daytona's macOS sandboxes are in early access.
Not ranked: misses a requirement6th cheapest of 35
$1,255 a month
Not ranked: misses a requirement

Key features

FeatureDaytonaNamespaceboat
IsolationContainer with its own namespaces by default; Linux VM and Windows VM classes with a hardware virtualization boundaryLinux Devboxes run a container image; the docs do not say if each has its own kernel (StarSling reports Firecracker)Every sandbox is a full VM with its own kernel; vCPUs are shared
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 result24.90 runs/s (shared rank 2)28.06 runs/s, second of 15 (shared rank 2), on an AMD Ryzen 9 9950X host
Real-repo builds (Better-Auth / Mastra / OpenClaw, same run, seconds, lower is better)156.6 / 1,112 / 571 on the Linux VM class150.5 / 1,051 / 570135.8 / 980 / 428
How long a session can runNo deadline by default; an optional time limit you set yourselfDevboxes stop at 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work; support can raise it to 24 at mostNo cap once auto-stop is off on a paid plan (default 1 h, up to 30 days)
Docker and nested virtualizationDocker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organizationDocker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or WindowsDocker, root, systemd and /dev/kvm on every sandbox
Desktop and computer useVNC desktop (xfce4) and a computer-use API on Linux and WindowsScreenshot and click API and VNC on macOS Devboxes; on Linux Devboxes you install a desktop yourself; VNC and RDP for compute instances1920x1080, 60 fps Linux 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)A stopped Devbox keeps its storage until you delete it, billed at $0.20 per GB-month usedDisk 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: pause, resume and fork with memory kept; containers start new sandboxes from filesystem snapshotsNo fork documented; compute instances suspend and resume with RAM keptFork a running sandbox from its last 1-minute snapshot; resume reboots from disk
Reaching the sandboxHTTPS preview URLs on any port, token-protected or public; SSH; no public IPHTTPS URLs that need a Namespace login; TCP through a running CLI port-forward; no public IPUp to 50 HTTPS URLs, token-gated by default; SSH; public IPv6, and raw ports over IPv4 only on sandboxes with their own IPv4
Outbound internetTier 1 and 2 reach only package registries, git hosts and AI APIs; Tier 3 ($500 top-up) and up get open internet plus domain or CIDR allowlistsEgress policies per Devbox blueprint, runner or instance: block, advisory or allow by domainOpen internet on every plan; no provider-side allowlist (firewall rules inside the VM)
Keeping keys out of the sandboxSecrets proxy swaps placeholders in HTTPS request headers for allowed hostsEgress rules inject a header from Namespace Vault, resolved outside the workloadOptional AI credentials proxy ($1 a day plus $1 per 1,000 requests) for model providers and HTTPS APIs you register
Coding agentsYou set it up: guides install agents and run them through process execYou run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions; hosts Claude Managed Agents, Cursor, Devin and Amp sessionsSeven harnesses preinstalled, with a prompt, steer and events API
GPUsNvidia and AMD GPUs, from RTX 4090 to B300, on-demand or preemptibleNone; machine shapes are CPU onlyNone
Operating systemsLinux, Windows VM sandboxes, and macOS in early accessLinux, macOS on Apple Silicon, and Windows on Team plans and upLinux only; Wine for Windows apps
RegionsUS and EU, plus dedicated regions or your own machines (BYOC)Several regions; keeping every workload in one region needs the Enterprise planGermany, Finland and France; no US or Asia region, no region choice
Every feature Battleships tracks (43)
FeatureDaytonaNamespaceboat
Full VM (own kernel)No documented wayYesYes
Docker insideYesYesYes
Nested virtualizationYesYesYes
RootYesYesYes
SystemdNot publishedNot publishedYes
Desktop GUIYesYesYes
BrowserYesWith your own setupYes
Computer-use APIYesYesYes
SSHYesYesYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
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 sessionsYesYesYes
Idle auto-stopYesYesNo documented way
Wake on requestNo documented wayYesNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayYesYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesYesYes
Secret proxy for any APIYesYesYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUYesNo documented wayNo documented way
WindowsYesYesNo documented way
Arm64No documented wayYesNo 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
Namespace24.90 runs/s
boat28.06 runs/s

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, Namespace 24.90 and Daytona's Linux VM class 21.52. All three share rank 2 of 15, so the run cannot separate them. On real-repo builds in the same run (Better-Auth / Mastra / OpenClaw, total seconds), boat took 135.8 / 980 / 428, Namespace 150.5 / 1,051 / 570 and Daytona VM 156.6 / 1,112 / 571. Daytona's default container class has no result. StarSling does not name the Namespace product it tested, and a Devbox's vCPU count is a ceiling it can boost to. 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). Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). 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.

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 monthNamespace, 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)$300 · Devbox on Business$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)$426 · Devbox on Business · 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)$2,448 · Devbox on Business$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$1,264 · Devbox Plus · 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$3,287 · Devbox Plus · with limits$8,800 · $2000/mo · with limits

Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, including while a sandbox starts or stops, and keeps billing the disk while it 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).

Namespace: Devboxes are billed in Devbox Minutes at $0.004 each; a 4 vCPU / 8 GB Devbox uses one a minute ($0.24 an hour). Pay as you go, or Devbox Plus at $250 a month for 50,000 minutes. Team ($100) and Business ($250) plan minutes do not cover Devboxes, but you need those plans for longer sessions and more Devboxes. Storage costs $0.20 per GB-month used, and new sign-ups get a 30-day trial with no card.

Namespace: 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 and memory running at once, up to 500 vCPU on Tier 4, so 300 sandboxes for your users and 1,000 short jobs at once need a custom limit, and Tiers 1 and 2 reach only an allowlist of services. Namespace's limits are time and count: a Devbox stops at 3, 5 or 24 hours by plan, so the agent that never stops restarts at least once a day, and Devboxes are capped at 50 per workspace on Business. Neither publishes an egress price. boat limits sandbox count and starts: the $2,000 plan includes 90 starts a minute and refuses starts above 270, so the 1,000-job burst does not fit there either.

ScenarioDaytonaNamespaceboat
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)
  • egress price not published
None 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)
  • Devbox on Business: sessions capped at 24 h
  • egress price not published
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)
  • egress price not published
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)
  • Devbox Plus: max 50 concurrent
  • egress price not published
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)
  • Devbox Plus: max 50 concurrent
  • egress price not published
  • 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 agents need GPUs, Windows, memory pause and fork, or sandboxes that run with no deadline in the US or the EU.

  • GPUs by the hour. Useful if your agents train or test models: Daytona rents Nvidia and AMD GPUs by the hour, and Namespace has none.
  • No clock on the sandbox. Useful for agents that run for days: a Daytona sandbox has no deadline by default, while a Namespace Devbox stops after 3 to 24 hours by plan.
  • Pause and fork with memory. Useful if a sandbox must come back exactly where it was: Daytona's VM classes pause and fork with memory kept.

Use Namespace when

you need macOS machines, faster GitHub Actions runners with build caches, or Devboxes for people that stop when idle.

  • macOS on Apple Silicon. Useful if your agents build iOS or Mac apps: Namespace runs macOS Devboxes on Apple M4 Pro and M5 Max chips with Xcode.
  • CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
  • Idle stop and egress rules. Useful for people's dev boxes: Devboxes stop when idle, start on connect, and can be limited to chosen domains.

Where boat fits

If what you are really running is coding agents on Linux for hours or days, look at boat. It gives every agent a full VM with no session cap once auto-stop is off, Docker and /dev/kvm, a 60 fps desktop, and coding agents you drive from outside. Pick Daytona for GPUs or Windows and Namespace for macOS or CI runners.

A full VM for every agent

A Daytona sandbox is a container with its own namespaces unless you pick its VM class and get KVM turned on. Namespace's docs do not say a Devbox has its own kernel, and /dev/kvm is on compute instances, not Devboxes.

CPU work in one public run

In StarSling's run of 3 October 2026, boat did 28.06 runs/s, Namespace 24.90 and Daytona's VM class 21.52. All three share rank 2, so the run cannot separate them. On the real-repo builds in the same run, boat took the least time on all three repos. The boat sandbox ran on a Ryzen 9 9950X host, and boat does not promise a CPU model.

Agents built in, driven from outside

On Daytona you install each agent and run it as a process; on Namespace you run it in a Devbox session, or a partner runs it. boat ships seven harnesses with a prompt, steer and events API.

Use boat when your agents work on Linux for hours or days: a full VM with no session cap once auto-stop is off, Docker and /dev/kvm, a 60 fps desktop, and coding agents you drive from outside. Compare it one to one: boat vs Daytona and boat vs Namespace.

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 Namespace?

For long sessions, usually yes, because an 8-hour Devbox session needs Namespace's Business plan. One coding agent on workdays comes to $56 a month on Daytona and $300 on Namespace Business. One agent running all month is $245 against $426, and on Namespace it restarts every 24 hours. 50 agents in parallel are $2,682 against $2,448. On boat those three come to $20, $26 and $317.

Which is faster, Daytona or Namespace?

In StarSling's run of 3 October 2026 at 4 vCPU / 8 GB, Namespace did 24.90 runs/s and Daytona's Linux VM class 21.52; boat did 28.06. All three share rank 2, so the run cannot separate them. Daytona's default container class has no result.

Can Daytona and Namespace run Docker?

Yes. Daytona runs Docker in all its classes, and Namespace includes Docker in Linux Devboxes. For /dev/kvm, Daytona needs its Linux VM class with KVM turned on for your organization, and Namespace offers it on Linux compute instances. boat has Docker, systemd and /dev/kvm on every sandbox.

Can a sandbox run 24/7 on Daytona or Namespace?

On Daytona, yes: a sandbox has no deadline by default and auto-stop can be turned off. A Namespace Devbox stops at 3, 5 or 24 hours by plan, even while you work in it, and support can raise it to 24 hours at most. On boat, auto-stop defaults to 1 hour; turn it off on a paid plan and there is no session cap.

Which one has GPUs or macOS?

Daytona rents Nvidia and AMD GPUs by the hour, runs Windows VMs, and has macOS in early access. Namespace runs macOS on Apple Silicon and Windows on Team plans and up, but has no GPUs. boat runs Linux only, with Wine for Windows apps.

Is boat SOC 2 compliant?

SOC 2 is in progress; boat has no SOC 2 report today. Daytona's Trust Center lists a SOC 2 Type II report, and Namespace's trust center lists SOC 2 Type II. Live status is at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons