Namespace vs AWS AgentCore

Namespace is a build and dev platform: CI runners, caches and Devboxes on Linux, macOS and Windows that stop after 3 to 24 hours by plan. AWS AgentCore is an AWS agent platform: microVM sessions of up to 8 hours, an Instances type on EC2 for up to 14 days, and a managed Code Interpreter and Browser, all inside your AWS account.

The companies and products

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.

AWS AgentCore

Amazon Bedrock AgentCore is a set of AWS services to deploy and run AI agents: a Runtime that hosts your agent code, plus built-in Code Interpreter and Browser tools.

AgentCore is not a sandbox product first. It is a hyperscaler's agent platform: you push a container image or code, and each Runtime session gets its own Firecracker microVM. You reach a session through AgentCore APIs, an interactive shell API and authenticated HTTPS session endpoints. Around it sit managed tools (Code Interpreter, Browser) and services for memory, identity, gateways and evaluations. An Instances compute type runs longer sessions on EC2 in your own account. It is built for teams who already build on AWS and want agents to stay inside their account, IAM and VPC.

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. “87th cheapest of 374” means 86 of the other 373 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 workloadNamespace: price rankAWS AgentCore: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
Both are a compromise for a software factory. A Namespace Devbox stops at its plan's limit, 24 hours at most. An AgentCore microVM has 2 vCPU, stops after 8 hours and keeps only files under /mnt mounts. boat ranks 5th with a full VM, Docker and a disk saved every minute.
74th of 365, with limits
$3,745 a month
132nd of 365, with limits
$888 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An assistant that never stops outlasts both. Namespace stops a Devbox within 24 hours, and AgentCore needs its Instances type on EC2 in your account, up to 14 days per session. boat ranks 6th and keeps running once auto-stop is off on a paid plan.
316th of 361, with limits
$6,645 a month
109th of 361, with limits
$1,300 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
AWS AgentCore fits best here, at 11th: Code Interpreter is built for short code runs and bills for CPU actually used. Namespace and boat are both compromises.
244th of 336, with limits
$250 a month
11th cheapest of 336
$114 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
AgentCore session endpoints reach a session's app ports, but each request needs an AWS signature or an OAuth token. Namespace URLs need a Namespace login. boat ranks 3rd and gives each sandbox HTTPS URLs on up to 50 ports, token-gated by default or public.
279th of 349, with limits
$2,068 a month
205th of 349, with limits
$506 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
345th of 349, with limits
$9,012 a month
129th of 349, with limits
$8,075 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
282nd of 359, with limits
$1,093 a month
46th cheapest of 359
$650 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
All three fit: boat at 2nd, AgentCore at 51st and Namespace at 87th. CI runners with build caches are Namespace's main product. boat runs CI jobs on full VMs with Docker and /dev/kvm.
87th cheapest of 374
$765 a month
51st cheapest of 374
$399 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. A Namespace Devbox stops at its plan's limit but keeps its storage. AgentCore has an interactive shell API but no SSH, and keeps only files under /mnt mounts after a stop. boat has SSH and saves its disk every minute.
201st of 371, with limits
$250 a month
242nd of 371, with limits
$52 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
108th of 367, with limits
$1,032 a month
146th of 367, with limits
$202 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
AWS AgentCore fits well, at 4th, with a managed Chromium that has live view and session replay. On Namespace you install Chrome or Playwright in your Devbox image. boat ranks 7th with Chrome on a full desktop.
191st of 356, with limits
$789 a month
4th cheapest of 356
$144 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
191st of 343, with limits
$332 a month
32nd cheapest of 343
$287 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
225th of 327, with limits
$9,012 a month
164th of 327, with limits
$5,458 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
112th of 351, with limits
$339 a month
108th of 351, with limits
$294 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
Not ranked: misses a requirementNot 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, at 6th: it runs macOS on Apple Silicon. AgentCore and boat have no macOS.
6th cheapest of 35
$1,255 a month
Not ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureNamespaceAWS AgentCoreboat
What it isA CI and dev platform: GitHub Actions runners, build caches and DevboxesAn AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser toolsA sandbox platform: each agent gets its own full Linux machine
IsolationLinux Devboxes run a container image; the docs do not say if each has its own kernel (a third-party benchmark reports Firecracker)Firecracker microVM per Runtime session; Code Interpreter and Browser in a containerized environmentFull VM with its own kernel, on a physical host dedicated to boat (AMD Ryzen 7 9700X or Ryzen 9 9950X; vCPUs are shared)
Machine size4 vCPU / 8 GB Devboxes and bigger sizes; a Devbox's vCPU count is a ceiling it can boost to2 vCPU / 8 GB per microVM session, not adjustable; on Instances, the EC2 instance type you pick sets the size4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above
CPU benchmark (V8 Web Tooling, 4 vCPU / 8 GB, StarSling run of 3 October 2026)24.90 runs/s, rank 2 of 15 (shared)Not in the run28.06 runs/s, rank 2 of 15 (shared); the run cannot separate boat and Namespace
How long a session can runDevboxes stop at 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you workUp to 8 hours per lifecycle on microVMs, stopped after 15 idle minutes by default; up to 14 days on InstancesNo session cap once auto-stop is off (default 1 hour; up to 30 days, or off on a paid plan)
Files after a stopA stopped Devbox keeps its storage until you delete it, billed at $0.20 per GB-month usedMounts under /mnt only: a 1 GB per-session storage mount (preview), your own EFS or S3 Files mounts in a VPC, or EBS volumes on Instances; the rest of the microVM resetsDisk saved every minute and at each stop; kept at least 14 days after a stop, longer with a saved snapshot
Fork and suspendNo fork documented; compute instances suspend and resume with RAM and disks keptNo snapshot or fork of a session; on Instances you can seed new EBS volumes from your own EBS snapshotsFork a running sandbox from its last 1-minute disk snapshot; a resume is like a reboot
Docker and /dev/kvmDocker in Linux Devboxes; /dev/kvm on Linux compute instancesRoot inside the microVM; Docker and /dev/kvm not documentedRoot, Docker, systemd and /dev/kvm on every sandbox
Reaching the sandboxHTTPS URLs that need a Namespace login, TCP through a running CLI port-forward; no public IPAuthenticated HTTPS session endpoint per microVM session for 1 to 5 ports (IAM or OAuth on every request, no public links); interactive shell API; no SSH or raw TCPHTTPS URLs for up to 50 ports, token-protected by default; raw ports over public IPv6; SSH; no dedicated IPv4
Network controlsEgress rules per Devbox blueprint, runner or instance: block, advisory or allow by domainVPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IPOpen internet; no provider-side allowlist
Browser and desktopmacOS Devboxes: screenshot and click API and a VNC desktop. Linux Devboxes: you set it up. Compute instances: VNC and RDPManaged Chromium with live view, session recording and replay, profiles and proxies; no desktop beyond the browser window1920x1080, 60fps Linux desktop with Chrome and computer tools
Coding agentsYou run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions; hosts Claude Managed Agents, Cursor, Devin and Amp sessions; no API to prompt or steer an agent from outsideAWS's own managed harness built on Strands Agents, or your own agent code in any frameworkSeven coding-agent harnesses installed, including Claude Code, Codex and OpenCode, with a prompt, steer and events API
Keeping keys out of the sandboxEgress rules inject a header from Namespace Vault, resolved outside the workloadAgentCore Identity stores OAuth tokens and API keys and hands them to your agent codeOptional paid AI credentials proxy ($1 a day while on, plus $1 per 1,000 requests) for supported model providers; other secrets still enter the sandbox
Operating systems and GPUsLinux, macOS on Apple Silicon, Windows on Team plans and up; CPU onlyarm64 Linux on microVMs; x86_64 or arm64 and NVIDIA G-series or Inferentia2 on InstancesLinux only, no GPU; Windows programs through Wine
RegionsNot compared here21 commercial AWS regions plus GovCloud (Instances in 9)Germany, Finland and France; you cannot pick one; no US or Asia region
Every feature Battleships tracks (43)
FeatureNamespaceAWS AgentCoreboat
Full VM (own kernel)YesYesYes
Docker insideYesNot publishedYes
Nested virtualizationYesNo documented wayYes
RootYesYesYes
SystemdNot publishedNo documented wayYes
Desktop GUIYesNo documented wayYes
BrowserWith your own setupYesYes
Computer-use APIYesYesYes
SSHYesNo documented wayYes
Persistent diskYesYesYes
Pause/resumeYesNo documented wayYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneNo documented wayNo documented wayYes
Live fork (no pause)No documented wayNo documented wayYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesNo documented wayYes
Idle auto-stopYesYesNo documented way
Wake on requestYesYesNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundYesNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo 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 serverYesYesNo documented way
GPUNo documented wayYesNo documented way
WindowsYesNo documented wayNo documented way
Arm64YesYesNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayYesNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsYesWith your own setupYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsYesYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAANo documented wayYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Namespace24.90 runs/s
AWS AgentCoreNot measured
boat28.06 runs/s

In StarSling's run of 3 October 2026 (run 37073680030), the V8 Web Tooling Benchmark at 4 vCPU / 8 GB did 28.06 runs/s on boat and 24.90 on Namespace. Both share rank 2 of 15, so the run cannot separate them. On real repo builds in the same run, boat took 135.8 s for Better-Auth against 150.5 s on Namespace. 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. AWS AgentCore is not in that run, and its microVM sessions stop at 2 vCPU, so a like-for-like test would use the Instances type.

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. 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. AWS AgentCore 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.

ScenarioNamespace, a monthAWS AgentCore, 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
$300 · Devbox on Business$26 · Pay-as-you-go (Instances) · with limits$20 · $20/mo
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$426 · Devbox on Business · with limits$107 · Pay-as-you-go (Instances) · 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,448 · Devbox on Business$1,286 · Pay-as-you-go (Instances) · with limits$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
$1,264 · Devbox Plus · with limits$423 · Pay-as-you-go · 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
$3,287 · Devbox Plus · with limits$1,615 · Pay-as-you-go (Instances)$8,800 · $2000/mo · with limits

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.

AWS AgentCore: No monthly fee. Runtime v1 microVMs, Code Interpreter and Browser bill per second: $0.0895 per vCPU-hour for CPU actually used and $0.00945 per GB-hour for peak memory. The 4 vCPU shape in these scenarios is the Instances type: the EC2 on-demand price plus a 12% management fee, with EBS storage and data transfer billed by AWS on top. The scenario prices leave out EBS storage.

AWS AgentCore: 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, and boat keeps its disk for at least 14 days; extra saved snapshots and the optional AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07 each.

Limits in those scenarios

On Namespace the limit that bites is time: a Devbox stops at 3 hours on Developer, 5 on Team and 24 on Business, so even one 8-hour workday needs Business, and the agent that never stops does not fit. Namespace also caps Devboxes at 3, 30 or 50 per workspace by plan, stopped ones included, and does not publish an egress price. On AgentCore, a 4 vCPU agent needs the Instances type, and files survive a stop only under /mnt mounts, so it does not fit the coding-agent scenarios; Instances sessions stop at 14 days. AgentCore fits 1,000 short jobs at once. boat caps sandboxes at once by plan and caps starts: at 1,000 short jobs at once, its $2,000 plan includes 90 starts a minute, charges $0.03 to $0.07 per extra start and refuses starts above 270 a minute. boat never queues a start, so it does not fit that burst.

ScenarioNamespaceAWS AgentCoreboat
One coding agent, workdays
  • egress price not published
  • files survive a stop only in capacity provider EBS volumes under /mnt: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
None for this scenario
One agent that never stops
  • Devbox on Business: sessions capped at 24 h
  • egress price not published
  • Pay-as-you-go (Instances): sessions capped at 336 h
  • files survive a stop only in capacity provider EBS volumes under /mnt: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
None for this scenario
50 agents in parallel
  • egress price not published
  • files survive a stop only in capacity provider EBS volumes under /mnt: packages installed elsewhere reset
  • disk beyond 0 GiB: price unknown
None for this scenario
Sandboxes for your users
  • Devbox Plus: max 50 concurrent
  • egress price not published
  • different kind of product: code interpreter
None for this scenario
1,000 short jobs at once
  • Devbox Plus: max 50 concurrent
  • egress price not published
  • disk beyond 0 GiB: price unknown
  • 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 Namespace when

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

  • macOS and Windows. Useful if your agents build iOS or Mac apps or test on Windows: Namespace runs macOS on Apple Silicon and Windows machines.
  • CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
  • Devboxes that sleep and wake. Useful for dev machines people share with agents: a Devbox stops when idle, keeps its storage and starts again when you connect.

Use AWS AgentCore when

your agents must stay inside your AWS account and VPC, need a GPU or a US or Asia region, or are short code and browser tasks that fit its managed tools.

  • It lives inside your AWS account. Teams built on AWS keep agents behind their own IAM, VPC, security groups and PrivateLink, in 21 commercial regions.
  • Managed code and browser tools. For short code runs and browser tasks, Code Interpreter and Browser bill for CPU actually used and peak memory, with live view and replay.
  • GPUs and two-week sessions. Agents that need a GPU or a session of up to 14 days can run on the Instances type, on EC2 in your account.

Where boat fits

If you run coding agents that work on one machine for hours or days, both Namespace and AgentCore put a clock on the session: Namespace at its plan's limit, 24 hours at most, and AgentCore's microVMs at 8 hours. boat gives each agent a full Linux VM that runs until you stop it once auto-stop is off, with a disk saved every minute and URLs you can share. boat's limits: start caps per plan, no GPU, no macOS, and no US or Asia region.

No clock on the session

A Namespace Devbox stops at 3, 5 or 24 hours by plan even mid-task, and an AgentCore microVM at 8 hours. AgentCore's longer option is Instances, which means running and paying for EC2 in your own account.

A whole machine that keeps its disk

AgentCore keeps only files under /mnt mounts after a stop, so packages installed elsewhere must be set up again, and neither documents a fork. boat is a full VM with Docker and /dev/kvm, saved every minute, that you can fork while it runs.

Share what the agent builds

AgentCore session endpoints need an AWS signature or OAuth token on every request, and Namespace URLs need a Namespace login. boat gives each sandbox HTTPS URLs on up to 50 ports, token-gated by default or public.

Use boat when your agents work on Linux for hours or days: a full VM with Docker and /dev/kvm, a disk saved every minute, a 60fps desktop and coding agents you drive from outside. Compare it one to one: boat vs Namespace and boat vs AWS AgentCore.

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 Namespace cheaper than AWS AgentCore?

In the scenarios we priced, AgentCore comes out lower, for example $1,286 against $2,448 for 50 agents in parallel, but AgentCore does not fit that scenario because files outside /mnt mounts reset after a stop. For 1,000 short jobs at once, AgentCore fits at $1,615, and Namespace does not fit at $3,287 because of its Devbox count cap. boat comes to $317 for the 50 agents.

Which is faster, Namespace or AgentCore?

Only Namespace is in StarSling's run of 3 October 2026: 24.90 V8 Web Tooling runs/s at 4 vCPU / 8 GB, against 28.06 for boat, and the run cannot separate those two. AgentCore is not in that benchmark, and its microVM sessions stop at 2 vCPU.

How long can a session run on each?

A Namespace Devbox stops at 3 hours on Developer and Devbox Plus, 5 on Team and 24 on Business, even while you work. An AgentCore microVM session lasts up to 8 hours and stops after 15 idle minutes by default, and the Instances type runs up to 14 days. boat has no session cap once auto-stop is off (default 1 hour).

Can Namespace or AgentCore run Docker?

Namespace Linux Devboxes include Docker, and its Linux compute instances expose /dev/kvm. AgentCore runs your container image as root in a microVM, but its docs do not say Docker or /dev/kvm work inside a session. boat runs Docker and exposes /dev/kvm on every sandbox.

Which one runs macOS or GPUs?

Namespace runs macOS on Apple Silicon and Windows on Team plans and up. AgentCore offers NVIDIA G-series and Inferentia2 on its Instances type. boat runs Linux only, without a GPU.

Is boat SOC 2 compliant?

No. boat's SOC 2 is in progress, and there is no SOC 2 report today. You can see boat's live status at status.ascii.dev and its data retention policy at docs.boat.dev/data-retention.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons