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 whose Devboxes, remote Linux and macOS machines for people and coding agents, are shut down after at most 24 hours.
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
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, and they also host sessions for Claude Managed Agents, Cursor Cloud Agents and Devin. It is a different kind of product from boat, so this page compares the part where they overlap: a machine an agent works on.
- Products
- GitHub Actions runners, Docker, Bazel, Turborepo and Nix caching, Devboxes, and a compute API
- Hardware
- Its own hardware in its own racks: AMD EPYC for Linux and Windows, Apple M4 Pro or M5 Max for macOS
- Linux Devboxes
- Run from a container image you choose and include Docker; the docs do not say whether each one has its own kernel
- Funding
- Announced a $42M Series B
- Compliance
- Trust center lists SOC 2 Type II
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 | Namespace: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 15th cheapest of 367 $4,111 a month | 39th of 367, with limits $3,495 a month | 3rd cheapest of 367 $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, while a Namespace Devbox is shut down after at most 24 hours even while it works; boat has no session cap on paid plans. | 24th cheapest of 366 $6,104 a month | 303rd of 366, with limits $6,645 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 one-minute runs well, creating hundreds of sandboxes a minute with no plan fee; Namespace is a compromise here, and boat's start limits make big bursts a compromise too. | 25th cheapest of 345 $271 a month | 247th of 345, with limits $250 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 Both are a compromise: 300 sandboxes of 2 vCPU need 600 vCPU, more than Daytona's Tier 4 pool of 500, and Namespace runs them on 4 vCPU Devboxes; boat ranks first. | 154th of 361, with limits $2,000 a month | 284th of 361, with limits $2,068 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 | 356th of 360, with limits $9,012 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 | 282nd of 364, with limits $1,043 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 Namespace fits because CI runners with Docker, Bazel and Turborepo caches are its main product, while Daytona caps a sandbox at 4 vCPU by default; boat runs CI jobs on full VMs. | 308th of 377, with limits $805 a month | 80th cheapest of 377 $765 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both are a compromise; a Namespace Devbox stops when idle and wakes when you connect but is shut down after at most 24 hours, while a boat machine stays up as long as you want. | 183rd of 368, with limits $245 a month | 126th of 368, with limits $168 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 fits with a VNC desktop and a computer-use API on Linux and Windows, while Namespace's screenshot and click API works on macOS Devboxes only; boat streams a 60fps Linux desktop. | 26th cheapest of 369 $1,198 a month | 67th of 369, with limits $982 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 | 285th of 367, with limits $789 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 | 259th of 346, with limits $332 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 | 226th of 338, with limits $9,012 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 | 12th cheapest of 360 $2,000 a month | 242nd of 360, with limits $339 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 Namespace and boat are CPU only. | 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 Only Namespace fits here: it runs macOS Devboxes and instances on Apple Silicon, and boat has no macOS. | Can't run it | 6th cheapest of 36 $1,205 a month | Can't run it |
Key features
| Feature | Daytona | Namespace | boat |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes have their own kernel | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | Every sandbox is a full VM with its own kernel |
| 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 | 21.79 runs/s | 26.69 runs/s |
| How long a session can run | No deadline by default; an optional time limit you set yourself | Devboxes stop after 4, 5 or 24 hours by plan, raisable to 24 at most | No session cap on paid plans |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, and KVM must be turned on for your organization | Docker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or Windows | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | 60fps Linux 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 | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | Snapshots every minute and on stop; a stopped sandbox costs nothing |
| Pause and fork | Linux VM and Windows: pause, resume and fork with memory kept; containers: no pause or fork | No fork; compute instances can suspend and resume with RAM kept | Fork a running sandbox into a new one; resume reboots from disk |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | HTTPS URLs that need a Namespace login, TCP through a running CLI port-forward; 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 package registries, git hosts and AI APIs; Tier 3 ($500 top-up) and up get open internet plus domain or CIDR allowlists | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Egress rules inject a header from Namespace Vault, resolved outside the workload | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Coding agents | Guides install agents and run them through process exec | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server lets your own agent create Devboxes | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| GPUs | Nvidia and AMD GPUs, from RTX 4090 to B300, on-demand or preemptible | None; machine shapes are CPU only | None |
| Operating systems | Linux, plus Windows VM sandboxes | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only; Wine for Windows apps |
| Regions | US and EU, plus dedicated regions or your own machines (BYOC) | Several regions; keeping every workload in one region needs the enterprise plan | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | Namespace | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | 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 | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | No | No |
| Windows | Yes | Yes | No |
| Arm64 | No | Yes | 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, Namespace did 21.79 Node.js build-and-test runs per second and Daytona's Linux VM class did 21.52, so the two are about even. Daytona's default container class reported no result, and a Namespace Devbox's vCPU count is a ceiling it can boost to, not a guaranteed share. boat did 26.69 runs per second in the same run.
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). Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015).
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 | Namespace, 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) | $50 · Devbox (pay as you go) | $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) | $176 · Devbox (pay as you go) · 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,198 · Devbox (pay as you go) | $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,214 · Devbox (pay as you go) | $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,237 · Devbox (pay as you go) | $2,000 · $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: 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, pay as you go on every plan; a 4 vCPU / 8 GB Devbox uses one a minute. The minutes in the Team and Business plans cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Namespace: 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 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 do not fit without a custom limit, and Tiers 1 and 2 reach only an allowlist of services. Namespace's limit is time: a Devbox is shut down after 4, 5 or 24 hours by plan, so the agent that never stops restarts at least once a day. Neither publishes an egress price. boat limits sandbox count and starts per minute, so the 1,000-job burst gets queued there too.
| Scenario | Daytona | Namespace | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| 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 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 within 24 hours.
- 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, faster VM with no session cap, Docker and /dev/kvm, a 60fps 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 on a shared kernel 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.
Faster CPU in the same test
In the same public run, boat did 26.69 runs per second, Namespace 21.79 and Daytona's VM class 21.52. Every install, build and test takes about a fifth to a quarter longer on either, and you pay for the waiting.
Agents built in, driven from outside
On Daytona you install each agent and run it as a process; on Namespace a partner runs the agent loop, or you write that code yourself. boat ships the agents with a prompt, steer and events API, and switches credentials when credits run out.
Use boat when your agents work on Linux for hours or days: a full, faster VM with no session cap, Docker and /dev/kvm, a 60fps desktop, and coding agents you drive from outside. Compare it one to one: boat vs Daytona and boat vs Namespace.
Questions people ask
Is Daytona cheaper than Namespace?
Namespace comes out a little lower in most scenarios we priced: one coding agent on workdays is $50 a month on Namespace and $56 on Daytona, and 50 agents in parallel are $2,198 against $2,682. One agent running all month is $176 on Namespace against $245 on Daytona, but on Namespace it must restart at least once a day. On boat those three come to $20, $317 and $26 a month.
Which is faster, Daytona or Namespace?
About the same in StarSling's public run at 4 vCPU / 8 GB: Namespace did 21.79 runs per second and Daytona's Linux VM class 21.52. Daytona's default container class reported no result. boat did 26.69 in the same run.
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 machine.
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 is shut down after 4, 5 or 24 hours by plan, even while you work in it, and support can raise it to 24 hours at most. boat has no session cap on paid plans.
Which one has GPUs or macOS?
Daytona rents Nvidia and AMD GPUs by the hour and runs Windows VMs. 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. We're open about where we stand: live status 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