Tensorlake vs AWS AgentCore
Tensorlake sells sandboxes: Firecracker microVMs that keep their memory while they sleep, copy into warm clones and have no session cap on Pro. AgentCore is the part of AWS that hosts agents: 2 vCPU microVM sessions that stop after 8 hours, or EC2 Instances for up to 14 days, inside your AWS account, IAM and VPC.
The companies and products
Tensorlake
Tensorlake is a San Francisco company that sells infrastructure for AI agents, with sandboxes as its main product.
Tensorlake Sandboxes are Firecracker microVMs that you create through an API and that boot in a few hundred milliseconds. CPU sandboxes have /dev/kvm, can resize CPU and memory while they run, and can suspend with their memory and running processes. You can copy a running sandbox into several warm clones. Around them Tensorlake sells pre-warmed pools, versioned Cloud Volumes, hosted Git and a bring-your-own-cloud option, aimed at teams running coding agents, evals and RL rollouts.
- Headquarters
- San Francisco
- Investors shown
- Redpoint and Amplify Partners
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. “8th cheapest of 365” means 7 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 workload | Tensorlake: 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 Tensorlake fits a software factory with Docker, /dev/kvm in CPU sandboxes and no session cap on Pro. AgentCore microVM sessions stop at 2 vCPU and 8 hours and keep only files under /mnt mounts. boat also has Docker and /dev/kvm, plus preinstalled coding agents. | 8th cheapest of 365 $1,315 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 Tensorlake keeps an always-on agent's files, and a named sandbox keeps its memory while it sleeps. On AgentCore it needs the Instances type on EC2 in your account, up to 14 days per session. boat keeps the machine running with no session cap once auto-stop is off (default 1 hour). | 14th cheapest of 361 $1,730 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 AgentCore Code Interpreter is built for short code runs and bills only CPU actually used. Tensorlake fits too, with 1,000 sandboxes at once on Pro. boat's start limits make bursts a compromise. | 29th cheapest of 336 $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 Tensorlake gives each user a sandbox with HTTP, WebSocket and gRPC on exposed ports, public or authenticated. AgentCore session endpoints reach app ports, but every request needs an AWS signature or an OAuth token. boat adds HTTPS URLs on up to 50 ports, token-gated by default or public. | 13th cheapest of 349 $561 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 Tensorlake is built for RL rollouts, with warm clones from one prepared state and 1,000 sandboxes at once on Pro. AgentCore has no session snapshot or fork. boat's start limits make large bursts a compromise. | 2nd cheapest of 349 $5,637 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 | 35th cheapest of 359 $506 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 | 53rd cheapest of 374 $424 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 A dev box needs SSH and a disk that keeps packages. Tensorlake has SSH and VS Code remote dev, but idles out after 10 minutes unless you raise the timeout. AgentCore has an interactive shell API, no SSH, and keeps only files under /mnt. boat has SSH and saves its disk every minute. | 202nd 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 Tensorlake gives agents an XFCE desktop with Firefox and mouse and keyboard calls. AgentCore Browser drives a browser window, not a whole desktop. boat streams a full Linux desktop at 60 fps. | 10th cheapest of 367 $387 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 AgentCore Browser is a managed Chromium with live view and session replay. Tensorlake runs a browser on its desktop image. boat runs Chromium on a full machine you control. | 12th cheapest of 356 $250 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 | 25th cheapest of 343 $250 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 | 123rd of 327, with limits $3,484 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 | 8th cheapest of 351 $250 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 | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Tensorlake | AWS AgentCore | boat |
|---|---|---|---|
| What it is | A sandbox product: microVMs you create through an API | 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 | Firecracker microVMs with their own kernel; GPU sandboxes use gVisor | Firecracker microVM per Runtime session; Code Interpreter and Browser in a containerized environment | Full VM with its own kernel on hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared |
| Biggest machine | Up to 16 vCPU / 64 GB with a 100 GB disk on Pro; CPU and memory resize on a running sandbox | 2 vCPU / 8 GB per microVM session, not adjustable; on Instances, the EC2 type you pick sets the size | Up to 16 vCPU / 32 GB / 251 GB disk on the $100 plan and above |
| Session length | No cap on Pro; an idle timeout (600 s by default) suspends or ends the sandbox | Up to 8 hours on microVMs, stopped after 15 idle minutes by default; up to 14 days on Instances | Auto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid plan for no cap |
| What survives a stop | Named sandboxes suspend with their disk, memory and running processes; Cloud Volumes keep files across sandboxes | Mounts under /mnt only: a 1 GB per-session mount (preview), your own EFS or S3 Files in a VPC, or EBS volumes on Instances; the rest resets | The disk, saved every minute and at each stop; memory, running programs and /tmp are not saved; kept at least 14 days after a stop |
| Snapshots and clones | Memory snapshots; copy a running sandbox into many warm clones | No snapshot or fork of a session; on Instances you can seed EBS volumes from your own EBS snapshots | Disk snapshot every minute; fork a running sandbox from its last 1-minute snapshot |
| Docker, systemd and /dev/kvm | Docker and systemd on the tensorlake/ubuntu-systemd image; /dev/kvm in CPU sandboxes | Root inside the microVM with your container image; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm on every sandbox, so Android emulators and VMs run |
| Inbound access | HTTP, WebSocket and gRPC on exposed ports (public or authenticated), SSH, and raw TCP through authenticated client tunnels; no dedicated IP | Authenticated HTTPS session endpoint for 1 to 5 ports on microVM sessions (IAM or OAuth on every request); interactive shell API; no SSH or raw TCP | Up to 50 HTTPS URLs, token-gated by default or public; SSH; raw ports on a public IPv6 address; no dedicated IPv4 |
| Network controls | allow_out and deny_out lists by domain, IP or CIDR, or no internet at all | VPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IP | Open internet, no provider-side allowlist; you set your own firewall as root |
| Browser and desktop | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Managed Chromium with live view, session recording and replay; no desktop beyond the browser window | Full Linux desktop and Chrome streamed at 1920x1080, 60 fps, with computer-use tools |
| Coding agents | You install your own agent in the sandbox or drive it from an agent outside; managed images are plain OS bases | AWS's managed harness built on Strands Agents, or your own agent code in your container image | Seven harnesses installed (Claude Code, Codex, OpenCode and more), with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox as environment variables | AgentCore Identity stores OAuth tokens and API keys and hands them to your agent code | Optional AI credentials proxy ($1 a day while on, plus $1 per 1,000 requests); with it on, real keys of supported providers stay outside; other secrets still enter |
| GPUs | GPU sandboxes by request, on gVisor; reserved H100 at $3.95 per GPU-hour | NVIDIA G-series and Inferentia2 on the Instances type | None |
| Where it runs | Managed cloud with EU data residency supported (no region list published), or your own cloud through BYOC | 21 commercial AWS regions plus GovCloud (Instances in 9), or EC2 in your account | Germany, Finland and France; you cannot pick one; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Tensorlake | 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 | Yes | No documented way | Yes |
| Desktop GUI | Yes | No documented way | Yes |
| Browser | Yes | 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 | Yes | No documented way | Yes |
| Live fork (no pause) | Yes | No documented way | Yes |
| Memory fork | Yes | 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 | No documented way | No documented way | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | No documented way | No documented way | Yes |
| Secret proxy for any API | No documented way | No documented way | Yes |
| Preinstalled agents | No documented way | No documented way | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | No documented way | Yes | No documented way |
| GPU | Yes | Yes | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | Yes | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | Yes | 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 | Not published | With your own setup | Yes |
| Usage per sandbox (API) | No documented way | No documented way | Yes |
| Audit logs | Not published | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | Yes | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Yes | Not published | Yes |
Performance
Tensorlake and AWS AgentCore are not in StarSling's CPU benchmark, 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. An AgentCore microVM session stops at 2 vCPU, so a like-for-like test would need its Instances type. In ComputeSDK's run of 6 November 2026, Tensorlake started 100 sandboxes at once with a median of 1.55 s to first command, at its default size. boat is not in ComputeSDK.
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. Tensorlake and AWS AgentCore are 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 | Tensorlake, 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 | $250 · Pro | $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 | $250 · Pro | $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 | $1,030 · Pro | $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 | $293 · Pro | $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 | $1,127 · Pro | $1,615 · Pay-as-you-go (Instances) | $8,800 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes 25,000 CU ($250) of usage, then $0.01 per CU. CPU is billed on active execution, with a minimum of 20% of allocated vCPU. RAM and disk bill on allocation while the sandbox runs, and a suspended sandbox pays $0.07 per GB-month of snapshot storage.
Tensorlake: Small users can skip Pro and buy prepaid Usage Credits packs of $5, $10 or $20 at higher rates, with no overage: sandboxes stop when the balance hits zero. A free plan runs 1 sandbox of 1 vCPU / 1 GB for up to 2 hours. The table prices the Pro path, so it overstates very small workloads.
AWS AgentCore: No monthly fee. Runtime microVMs, Code Interpreter and Browser bill per second for CPU actually used and 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 (billed also while a session is stopped) 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; unused time does not carry over. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs, busy or idle. A stopped sandbox has no compute charge, and boat keeps its disk for at least 14 days. Saved snapshots above the included count and the optional AI credentials proxy still charge while sandboxes are stopped. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07 each.
Limits in those scenarios
Tensorlake fits all five scenarios on Pro, which allows 1,000 sandboxes at once. On Tensorlake, disk is 10 to 100 GiB and can only grow, memory can't shrink below its boot size, and an ephemeral sandbox ends after 10 idle minutes by default. AgentCore's microVM sessions stop at 2 vCPU / 8 GB and 8 hours, so the 4 vCPU scenarios need the Instances type. Files outside /mnt mounts reset after a stop, so packages installed at run time must be installed again unless the container image has them; that is why AgentCore fits only the 1,000 short jobs scenario in our table. boat's limit is start rate: the $2,000 plan includes 90 starts a minute and 2,400 a day, extra starts cost $0.03 to $0.07, and starts above 270 a minute fail with 429, so 1,000 short jobs at once does not fit. A boat resume is like a reboot, and a machine failure loses the writes after the last 1-minute snapshot.
| Scenario | Tensorlake | AWS AgentCore | boat |
|---|---|---|---|
| One coding agent, workdays | None for this scenario |
| None for this scenario |
| One agent that never stops | None for this scenario |
| None for this scenario |
| 50 agents in parallel | None for this scenario |
| None for this scenario |
| Sandboxes for your users | None for this scenario |
| None for this scenario |
| 1,000 short jobs at once | None for this scenario |
|
|
Which one should you use?
Use Tensorlake when
you fan out many short rollouts from one warm state, need sandboxes that sleep with their memory, need GPUs, or want them in your own cloud account.
- Memory snapshots and warm clones. Useful when agents must pick up mid-process: Tensorlake saves a sandbox's memory and copies it into warm clones.
- Bigger sandboxes with no session cap. Tensorlake Pro goes up to 16 vCPU and 64 GB with no session cap, and resizes CPU and memory on a running sandbox. AgentCore microVM sessions stop at 2 vCPU and 8 hours.
- Ports, SSH and tunnels. Tensorlake exposes HTTP, WebSocket and gRPC ports, public or authenticated, plus SSH and raw TCP through client tunnels.
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 the 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 tools for short tasks. For short code runs and browser tasks, Code Interpreter and Browser charge for CPU actually used and peak memory, with live view and replay.
- GPUs and two-week sessions on Instances. Agents that need a GPU or a session of up to 14 days can run on EC2 in your account, with Savings Plans applying.
Where boat fits
If your agents do long, steady work on a machine, such as installs, builds, tests, Docker, emulators and previews, look at boat. It gives each agent a full VM that saves its disk every minute and has no session cap once auto-stop is off (default 1 hour). Tensorlake is ahead for memory snapshots, warm clones and GPUs. AgentCore is ahead for staying inside AWS. boat has no GPU, no memory snapshots and no region outside Europe.
A whole machine for hours
An AgentCore microVM session stops at 2 vCPU / 8 GB and 8 hours, so longer or bigger work needs the Instances type on EC2. Tensorlake Pro has no cap but ends or suspends a sandbox after 10 idle minutes by default. boat gives up to 16 vCPU with root, Docker, systemd and /dev/kvm, and bills at full rate while it runs, busy or idle.
Share a link to what the agent builds
AgentCore session endpoints need an AWS signature or an OAuth token on every request. Tensorlake can make ports public, and reaches raw TCP only through authenticated client tunnels, with no dedicated IP. boat gives up to 50 HTTPS URLs, token-gated by default or public, SSH and raw ports on a public IPv6 address.
Coding agents built in, keys kept outside
On both, you set up the agent harness yourself or use AWS's own. Tensorlake injects secrets into the sandbox, and AgentCore hands keys to your agent code. boat installs seven agents, and its optional proxy ($1 a day while on, plus $1 per 1,000 requests) keeps real keys of supported providers outside.
Use boat when your agents do steady work for hours: installs, builds, tests, Docker, emulators and a desktop, with a disk saved every minute, URLs you can share and coding agents built in. Compare it one to one: boat vs Tensorlake 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 Tensorlake cheaper than AWS AgentCore?
For 1,000 short jobs at once, the one scenario both fit, Tensorlake is $1,127 a month against $1,615 on AgentCore. AgentCore's Instances bills look lower for one coding agent on workdays ($26 against $250), but packages installed outside /mnt reset after each stop, and EBS storage is extra. A nearly idle agent can cost less on AgentCore microVMs or Tensorlake, which bill CPU only while busy. boat is $20 for that workday agent and does not fit the 1,000-job burst.
Which is faster, Tensorlake or AgentCore?
We cannot say: neither is in StarSling's CPU benchmark. On size, Tensorlake Pro goes up to 16 vCPU, while an AgentCore microVM session stops at 2 vCPU; Instances can be larger. boat did 28.06 V8 Web Tooling runs/s, second of 15 in StarSling's run of 3 October 2026, on a Ryzen 9 9950X host.
Can Tensorlake or AgentCore run Docker?
Tensorlake runs Docker on its tensorlake/ubuntu-systemd image. AgentCore runs your container image as root in a microVM, but its docs do not say Docker works inside a session. boat runs Docker with root and systemd.
How long can a session run on each?
Tensorlake Pro has no session cap, though an idle timeout of 600 seconds by default suspends or ends a sandbox. An AgentCore microVM session lasts up to 8 hours and stops after 15 idle minutes by default; the Instances type runs up to 14 days. On boat, auto-stop defaults to 1 hour; on a paid plan you can turn it off for no cap.
Which one keeps a sandbox's state?
Tensorlake named sandboxes suspend with their memory and running processes, and can be copied into warm clones. AgentCore keeps only paths under /mnt: a 1 GB session mount in preview, your own EFS or S3 Files, or EBS volumes on Instances. boat saves the disk every minute and at each stop and can fork a running sandbox; memory is not saved.
Do they support nested virtualization?
Tensorlake CPU sandboxes have /dev/kvm, so VMs run inside them; GPU sandboxes do not. AgentCore does not document /dev/kvm. boat exposes /dev/kvm on every sandbox.
Try boat
Install the CLI, then run boat new.
7-day free trial