boat vs Datalayer

Datalayer is a platform for data agents built on Jupyter. Its sandboxes are Kubernetes pods with a Python kernel, and coding agents can run in them behind its Shield rules. boat gives each agent a full Linux VM with root and Docker, so the agent can install tools while it works and host what it builds.

Where boat stands out

A whole Linux machine, not a Python kernel

Each boat sandbox is a full VM with its own kernel, root, systemd, Docker and /dev/kvm. An agent can install a language while it works, run a database, build containers or start an Android emulator. A Datalayer sandbox is a Python kernel in a Kubernetes pod. You add other tools at build time with apt, conda or a Dockerfile on an approved base, and no Docker daemon inside is documented.

Bigger machines, no time reservation

boat sizes go up to 16 vCPU / 32 GB; that size needs the $100 plan or higher. On a paid plan you can turn auto-stop off (default 1 hour), so a sandbox runs until you stop it. The disk is saved every minute and at each stop; memory and running programs are not. Datalayer's largest CPU size is 8 CPU / 16 GiB, and a code sandbox runs for a time you reserve up front.

Coding agents and hosting built in

Claude Code, Codex and five other agents are installed, and you drive them from outside with a prompt, steer and events API. What they build is live on up to 50 HTTPS URLs per sandbox. With the optional paid credentials proxy on, the real keys of supported AI providers stay outside the sandbox.

The companies and products

boat

boat.dev runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.

You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.

Datalayer

Datalayer builds open and trusted agent applications for data analysis, on top of Jupyter notebooks.

Datalayer is a different kind of product: an agent studio and notebook platform, with Runtimes and Code Sandboxes as the place where agent code runs. A Datalayer sandbox is a Python Jupyter kernel in a Kubernetes pod. You build its environment from an approved Datalayer base, and you can add apt packages, conda packages or a Dockerfile step. Applications also get a Computer with a shell, files and a preview browser, and Claude Code, Codex, OpenCode or pi can run in it. This page compares the two where they overlap: running agent code in the cloud.

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. “5th cheapest of 365” means 4 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 workloadboat: price rankDatalayer: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
A software factory needs Docker and many toolchains while the agent works. Datalayer adds tools at environment build time on a Python base, and documents no Docker daemon inside a runtime. boat sandboxes run Docker with root, and the agent installs tools at run time.
5th cheapest of 365
$634 a month
147th of 365, with limits
$1,014 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An assistant that runs all month needs a machine that stays on. Datalayer can keep an application always on under a daily spend limit. On boat, you turn auto-stop off on a paid plan (default 1 hour), and the sandbox keeps its disk.
6th cheapest of 361
$657 a month
248th of 361, with limits
$2,102 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
This is closest to what Datalayer does: Python code runs in a notebook kernel, and the kernel state can be paused, snapshotted and loaded elsewhere.
189th of 336, with limits
$2,000 a month
215th of 336, with limits
$96 a month
Sandboxes for your users
300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month
Giving each of your users a machine means hosting their apps. boat gives up to 50 public HTTPS URLs per sandbox, token-gated by default. Datalayer documents no per-port public URL for a sandbox.
3rd cheapest of 349
$209 a month
219th of 349, with limits
$670 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
39th of 349, with limits
$2,000 a month
241st of 349, with limits
$2,880 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
Agent evals that run coding agents need a full machine per run. boat has seven agents installed and an API to prompt, steer and watch them from outside. Datalayer runs Claude Code, Codex, OpenCode and pi in its runtimes, behind its Shield rules.
10th cheapest of 359
$200 a month
243rd of 359, with limits
$288 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
CI jobs need Docker and many toolchains. Datalayer installs extra tools at image build time on a Python base, with no Docker daemon documented inside. boat sandboxes run Docker on their own kernel.
2nd cheapest of 374
$86 a month
241st of 374, with limits
$138 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
A dev box needs SSH, root and a disk that stays. boat gives all three. Datalayer runtimes are reached through notebooks, a terminal, the CLI and MCP, and files stay in the Home Folder or an attached Volume.
19th cheapest of 371
$26 a month
235th of 371, with limits
$42 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
Computer-use agents need a desktop and a browser. boat streams a full desktop with Chrome at 60 fps. Datalayer has a preview web browser for its applications and no desktop.
7th cheapest of 367
$200 a month
167th of 367, with limits
$288 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
7th cheapest of 356
$200 a month
182nd of 356, with limits
$288 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
6th cheapest of 343
$90 a month
178th of 343, with limits
$144 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
73rd of 327, with limits
$1,800 a month
106th of 327, with limits
$2,880 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
3rd cheapest of 351
$200 a month
205th of 351, with limits
$144 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min 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 requirement

Key features

FeatureboatDatalayer
What runs insideFull VM with its own kernel, on physical hosts dedicated to boat; vCPUs are sharedA Python Jupyter kernel in a Kubernetes pod
LanguagesAny Linux software, installed at build or run timePython kernel; other tools through apt or conda packages, or a Dockerfile on an approved Datalayer base
Machine size2 to 16 vCPU, up to 32 GB; 16 vCPU needs the $100 plan or highersmall 1 CPU / 2 GiB, medium 4 CPU / 8 GiB, large 8 CPU / 16 GiB
Docker and nested virtualizationDocker, systemd, root and /dev/kvmA Dockerfile is used at build time, FROM an approved base; no Docker daemon or /dev/kvm documented inside a runtime
Custom imagesStart from boat's image or a saved snapshot; you cannot boot your own Docker or OCI imageEnvironments from YAML, a lock file or a Dockerfile that starts from an approved Datalayer base
Session lengthAuto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid planCode sandboxes run for a time reserved up front (pausable); applications can be kept always on under a daily spend limit
Saved stateDisk saved every minute and at each stop; memory and running programs are not savedPause keeps a sandbox's state; Runtime Snapshots keep Python variables; Home Folder and Volumes keep files
ForkFork a running sandbox from its last 1-minute disk snapshotSnapshot a running kernel, then launch a new sandbox from it
AccessSSH, API and a 60 fps desktop with ChromeNotebooks, a terminal, the CLI and a hosted MCP server; no SSH documented
Inbound accessUp to 50 public HTTPS URLs per sandbox, token-gated by defaultNo per-port public URL documented
Outbound networkOpen outbound internet over IPv6 and IPv4; egress is not billedRuntime pods reach no outside host by default; an Appspec can grant a host, and the Shield logs and refuses the rest
Coding agentsSeven agents installed, with a prompt, steer and events APIClaude Code, Codex, OpenCode and pi run in a runtime behind its Shield rules, on your own Anthropic or OpenAI key; any MCP client can also connect from outside
Notebook toolsYou set it up: install Jupyter in the sandboxNotebooks built in; execution keeps going after the browser or agent disconnects
GPUsNo GPU on any sizeNot on Datalayer itself; through your own Modal, Daytona, CoreWeave or Kaggle account, billed by that provider
Self-hostingNo self-hostingAgent Nodes on your own AWS account or machine; on-premise option on Enterprise
ComplianceSOC 2 in progress; no SOC 2 report todaySOC 2 Type II, ISO 27001 and ISO 42001
Compliance and transparencySOC 2 is in progress. We're open about where we stand: live status and data retention policy.SOC 2
Every feature Battleships tracks (43)
FeatureboatDatalayer
Full VM (own kernel)YesNo documented way
Docker insideYesNo documented way
Nested virtualizationYesNo documented way
RootYesNot published
SystemdYesNot published
Desktop GUIYesNo documented way
BrowserYesWith your own setup
Computer-use APIYesNo documented way
SSHYesNo documented way
Persistent diskYesYes
Pause/resumeYesYes
Automatic snapshotsYesNo documented way
Fork/cloneYesYes
Live fork (no pause)YesYes
Memory forkNo documented wayNo documented way
Custom image (Docker or snapshot)YesYes
≥24 h sessionsYesYes
Idle auto-stopNo documented wayNo documented way
Wake on requestNo documented wayNo documented way
HTTPS preview URLsYesNo documented way
Raw TCP inboundYesNot published
Public IPv4No documented wayNo documented way
Egress allowlistNo documented wayYes
Secret proxyYesNo documented way
Secret proxy for any APIYesNo documented way
Preinstalled agentsYesYes
Agent harness APIYesNot published
MCP serverNo documented wayYes
GPUNo documented wayNo documented way
WindowsNo documented wayNo documented way
Arm64No documented wayNo documented way
Self-hostingNo documented wayYes
BYOCNo documented wayYes
Open sourceNo documented wayNo documented way
Scoped API keysYesNot published
Spend limitsYesYes
Usage per sandbox (API)YesNo documented way
Audit logsNo documented wayYes
SSONo documented wayYes
SOC 2No documented wayYes
HIPAANo documented wayNo documented way
EU data residencyNo documented wayNo documented way
Zero data retentionYesNot published

Performance

boat28.06 runs/s
DatalayerNot measured

Datalayer is not in the public benchmarks we use, so we cannot say which is faster. In StarSling's run of 3 October 2026 (run 37073680030), boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15. 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.

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. 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. Datalayer 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.

Scenarioboat, a monthDatalayer, 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
$20 · $20/mo$10 · Free · with limits
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$26 · $20/mo$42 · Free · with limits
50 agents in parallel
50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside
$317 · $20/mo × 3 seats$507 · Free · with limits
Sandboxes for your users
2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once
$200 · $100/mo × 2 seats$288 · Free · with limits
1,000 short jobs at once
2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month
$8,800 · $2000/mo · with limits$576 · Free · with limits

boat: Plans cost $20, $100, $500 or $2,000 a month. The whole plan price comes back as VM time for that month, and it does not carry over. You pay per second while a sandbox runs: $0.036 an hour for 4 vCPU / 8 GB, busy or idle. A stopped sandbox has no compute charge, but extra saved snapshots and the AI credentials proxy still charge. The $20 plan includes 12 starts a minute, 60 an hour and 200 a day. Each create, fork or resume is a start. Extra starts cost $0.03 to $0.07 each, and starts above 1,200 a day or 36 a minute are refused. A card is required, also for the 7-day trial.

Datalayer: Datalayer bills credits per second while a runtime runs, busy or idle. The docs list small 1 CPU / 2 GiB at 0.0008 credits a second, medium 4 CPU / 8 GiB at 0.0016 and large 8 CPU / 16 GiB at 0.0032. A credit is a cent, and the docs call these prices provisional, so medium is about $0.058 an hour. A code sandbox takes its time reservation from your credits at launch. Plans: Free with 50 wallet credits a month, Team at $49 a month plus $15 per active member, and Enterprise on request.

Limits in those scenarios

Datalayer's medium size (4 CPU / 8 GiB) matches the 4 vCPU / 8 GB shape, but no scenario is a full fit. Runtime pods reach no outside network or package index by default, no Docker daemon inside is documented, and files survive a stop only in the Home Folder or an attached Volume. Datalayer does not publish how many runtimes can run at once or what extra disk costs. It has no 2 vCPU size, so the table prices medium for the two 2 vCPU scenarios. boat fits four of the five. For 1,000 short jobs at once, boat's $2,000 plan charges for starts above 90 a minute and refuses starts above 270 a minute, so that scenario costs about $8,800 a month on boat.

ScenarioboatDatalayer
One coding agent, workdaysNone for this scenario
  • files survive a stop only in Home Folder or an attached Volume: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
  • egress price not published
One agent that never stopsNone for this scenario
  • files survive a stop only in Home Folder or an attached Volume: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
  • egress price not published
50 agents in parallelNone for this scenario
  • missing Docker inside
  • files survive a stop only in Home Folder or an attached Volume: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
  • egress price not published
Sandboxes for your usersNone for this scenario
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
  • disk beyond 0 GiB: price unknown
  • egress price not published
1,000 short jobs at once
  • 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
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • disk beyond 0 GiB: price unknown
  • egress price not published
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

Which one should you use?

Use Datalayer when

your agents do Python data analysis in Jupyter notebooks that your team shares, when you need SOC 2 Type II or ISO 27001 today, or when you want GPUs through another provider or agents on your own AWS account.

  • Notebooks and MCP for data agents. Good for data teams: any MCP agent can read, edit and run the notebooks your team already shares.
  • Python state you can move. Useful for analysis work: a kernel's Python variables can be saved and loaded into another sandbox.
  • Other clouds, your own servers, audited compliance. Code sandboxes run on six other providers, agents run on your own AWS account, and compliance reports are in place today.

Use boat when

your agents need a full Linux machine: languages installed while they work, Docker, a desktop with Chrome, up to 16 vCPU / 32 GB, and HTTPS URLs to show what they made.

  • A whole Linux machine, not a Python kernel. Coding agents run npm, cargo, Docker and test servers, and they often need a new tool in the middle of a task. On boat the agent installs it. On Datalayer you rebuild the environment, because a runtime pod reaches no package index by default.
  • Bigger machines, no time reservation. A large build or test suite can need more than 16 GiB of memory. With a reservation, you choose the run time before the agent starts.
  • Coding agents and hosting built in. Datalayer runs coding agents in its runtimes, but a runtime cannot reach a package index or the open internet by default, and there is no per-port URL to show the app they built.

Questions people ask

Is Datalayer a sandbox provider like boat?

Partly. Datalayer is a platform for data agents built on Jupyter. Its Code Sandboxes run a Python kernel in a Kubernetes pod, and its applications can run coding agents. boat gives each agent a full Linux VM with root, Docker and SSH.

Is boat cheaper than Datalayer?

It depends on the scenario, at Datalayer's provisional rates. One 4 vCPU / 8 GB agent running all month costs $26 on boat and about $42 on Datalayer medium. 50 agents in parallel cost $317 on boat and $507 on Datalayer. One agent on workdays costs about $10 on Datalayer and $20 on boat, because boat's smallest plan is $20. 1,000 short jobs at once cost $576 on Datalayer and about $8,800 on boat, but Datalayer does not publish how many runtimes can run at once. Datalayer does not fully fit any of the five scenarios.

Can I run Docker or Node.js in a Datalayer sandbox?

Node.js, yes: add it as an apt package or in a Dockerfile on an approved Datalayer base when you build the environment. A Docker daemon inside a running runtime is not documented. boat sandboxes run Docker and Node.js with root, and the agent can install more while it works.

Can Claude Code use Datalayer?

Yes, two ways. Claude Code, Codex, OpenCode and pi run inside a Datalayer runtime on your own API key, or they connect from outside to its hosted MCP server. On boat, seven agents run inside the sandbox with open internet and root, and you drive them with an API.

Does Datalayer have GPUs?

Not on Datalayer itself. A GPU environment builds for your own Modal or Daytona account, and code sandboxes can also run on CoreWeave or a Kaggle GPU session. That provider bills the GPU. boat has no GPU on any size.

Is boat SOC 2 compliant?

Not yet. SOC 2 is in progress, and boat has no SOC 2 report today. Datalayer has SOC 2 Type II, ISO 27001 and ISO 42001. Live status: status.ascii.dev. Data retention policy: docs.boat.dev/data-retention.

Start a sandbox

Install the CLI, then run boat new.

7-day free trial

More comparisons