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.
- 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 a container image you choose and include Docker; the docs do not say if each one has its own kernel
- Devbox time limit
- 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work; support can raise it to 24 hours at most
- Devbox count limit
- Per user / per workspace: 1/3 on Developer, 3/30 on Team, 5/50 on Business and Devbox Plus; stopped Devboxes count
- Free trial
- 30-day Developer trial with no card
- Compliance
- Trust center lists SOC 2 Type II
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 workload | Namespace: price rank | AWS AgentCore: price rank | boat: 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 requirement | Not ranked: misses a requirement | Not 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 requirement | Not ranked: misses a requirement |
Key features
| Feature | Namespace | AWS AgentCore | boat |
|---|---|---|---|
| What it is | A CI and dev platform: GitHub Actions runners, build caches and Devboxes | An AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser tools | A sandbox platform: each agent gets its own full Linux machine |
| Isolation | Linux 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 environment | Full VM with its own kernel, on a physical host dedicated to boat (AMD Ryzen 7 9700X or Ryzen 9 9950X; vCPUs are shared) |
| Machine size | 4 vCPU / 8 GB Devboxes and bigger sizes; a Devbox's vCPU count is a ceiling it can boost to | 2 vCPU / 8 GB per microVM session, not adjustable; on Instances, the EC2 instance type you pick sets the size | 4 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 run | 28.06 runs/s, rank 2 of 15 (shared); the run cannot separate boat and Namespace |
| How long a session can run | Devboxes stop at 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work | Up to 8 hours per lifecycle on microVMs, stopped after 15 idle minutes by default; up to 14 days on Instances | No session cap once auto-stop is off (default 1 hour; up to 30 days, or off on a paid plan) |
| Files after a stop | A stopped Devbox keeps its storage until you delete it, billed at $0.20 per GB-month used | Mounts 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 resets | Disk saved every minute and at each stop; kept at least 14 days after a stop, longer with a saved snapshot |
| Fork and suspend | No fork documented; compute instances suspend and resume with RAM and disks kept | No snapshot or fork of a session; on Instances you can seed new EBS volumes from your own EBS snapshots | Fork a running sandbox from its last 1-minute disk snapshot; a resume is like a reboot |
| Docker and /dev/kvm | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Root inside the microVM; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm on every sandbox |
| Reaching the sandbox | HTTPS URLs that need a Namespace login, TCP through a running CLI port-forward; no public IP | Authenticated 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 TCP | HTTPS URLs for up to 50 ports, token-protected by default; raw ports over public IPv6; SSH; no dedicated IPv4 |
| Network controls | Egress rules per Devbox blueprint, runner or instance: block, advisory or allow by domain | VPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IP | Open internet; no provider-side allowlist |
| Browser and desktop | macOS Devboxes: screenshot and click API and a VNC desktop. Linux Devboxes: you set it up. Compute instances: VNC and RDP | Managed Chromium with live view, session recording and replay, profiles and proxies; no desktop beyond the browser window | 1920x1080, 60fps Linux desktop with Chrome and computer tools |
| Coding agents | You 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 outside | AWS's own managed harness built on Strands Agents, or your own agent code in any framework | Seven coding-agent harnesses installed, including Claude Code, Codex and OpenCode, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Egress rules inject a header from Namespace Vault, resolved outside the workload | AgentCore Identity stores OAuth tokens and API keys and hands them to your agent code | Optional 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 GPUs | Linux, macOS on Apple Silicon, Windows on Team plans and up; CPU only | arm64 Linux on microVMs; x86_64 or arm64 and NVIDIA G-series or Inferentia2 on Instances | Linux only, no GPU; Windows programs through Wine |
| Regions | Not compared here | 21 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)
| Feature | Namespace | AWS AgentCore | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | Yes | No documented way | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No documented way | Yes |
| Desktop GUI | Yes | No documented way | Yes |
| Browser | With your own setup | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | No documented way | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No documented way | Yes |
| Automatic snapshots | Yes | No documented way | Yes |
| Fork/clone | No documented way | No documented way | Yes |
| Live fork (no pause) | No documented way | No documented way | Yes |
| Memory fork | No documented way | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No documented way | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | Yes | Yes | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No documented way | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | No documented way | Yes |
| Secret proxy for any API | Yes | No documented way | Yes |
| Preinstalled agents | Yes | No documented way | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | No documented way | Yes | No documented way |
| Windows | Yes | No documented way | No documented way |
| Arm64 | Yes | Yes | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | No documented way | Yes | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | With your own setup | Yes |
| Usage per sandbox (API) | No documented way | No documented way | Yes |
| Audit logs | Yes | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | No documented way | Yes | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
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.
| Scenario | Namespace, a month | AWS AgentCore, 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 | $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.
| Scenario | Namespace | AWS AgentCore | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None for this scenario |
| One agent that never stops |
|
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 1,000 short jobs at once |
|
|
|
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