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

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 workloadTensorlake: price rankAWS AgentCore: price rankboat: 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 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
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureTensorlakeAWS AgentCoreboat
What it isA sandbox product: microVMs you create through an APIAn AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser toolsA sandbox platform: each agent gets its own full Linux machine
IsolationFirecracker microVMs with their own kernel; GPU sandboxes use gVisorFirecracker microVM per Runtime session; Code Interpreter and Browser in a containerized environmentFull VM with its own kernel on hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
Biggest machineUp to 16 vCPU / 64 GB with a 100 GB disk on Pro; CPU and memory resize on a running sandbox2 vCPU / 8 GB per microVM session, not adjustable; on Instances, the EC2 type you pick sets the sizeUp to 16 vCPU / 32 GB / 251 GB disk on the $100 plan and above
Session lengthNo cap on Pro; an idle timeout (600 s by default) suspends or ends the sandboxUp to 8 hours on microVMs, stopped after 15 idle minutes by default; up to 14 days on InstancesAuto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid plan for no cap
What survives a stopNamed sandboxes suspend with their disk, memory and running processes; Cloud Volumes keep files across sandboxesMounts 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 resetsThe 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 clonesMemory snapshots; copy a running sandbox into many warm clonesNo snapshot or fork of a session; on Instances you can seed EBS volumes from your own EBS snapshotsDisk snapshot every minute; fork a running sandbox from its last 1-minute snapshot
Docker, systemd and /dev/kvmDocker and systemd on the tensorlake/ubuntu-systemd image; /dev/kvm in CPU sandboxesRoot inside the microVM with your container image; Docker and /dev/kvm not documentedRoot, Docker, systemd and /dev/kvm on every sandbox, so Android emulators and VMs run
Inbound accessHTTP, WebSocket and gRPC on exposed ports (public or authenticated), SSH, and raw TCP through authenticated client tunnels; no dedicated IPAuthenticated HTTPS session endpoint for 1 to 5 ports on microVM sessions (IAM or OAuth on every request); interactive shell API; no SSH or raw TCPUp to 50 HTTPS URLs, token-gated by default or public; SSH; raw ports on a public IPv6 address; no dedicated IPv4
Network controlsallow_out and deny_out lists by domain, IP or CIDR, or no internet at allVPC mode with security groups, PrivateLink and a NAT gateway for a fixed outbound IPOpen internet, no provider-side allowlist; you set your own firewall as root
Browser and desktopXFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard callsManaged Chromium with live view, session recording and replay; no desktop beyond the browser windowFull Linux desktop and Chrome streamed at 1920x1080, 60 fps, with computer-use tools
Coding agentsYou install your own agent in the sandbox or drive it from an agent outside; managed images are plain OS basesAWS's managed harness built on Strands Agents, or your own agent code in your container imageSeven harnesses installed (Claude Code, Codex, OpenCode and more), with a prompt, steer and events API
API keysStored secrets are injected into the sandbox as environment variablesAgentCore Identity stores OAuth tokens and API keys and hands them to your agent codeOptional 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
GPUsGPU sandboxes by request, on gVisor; reserved H100 at $3.95 per GPU-hourNVIDIA G-series and Inferentia2 on the Instances typeNone
Where it runsManaged cloud with EU data residency supported (no region list published), or your own cloud through BYOC21 commercial AWS regions plus GovCloud (Instances in 9), or EC2 in your accountGermany, Finland and France; you cannot pick one; no US or Asia region
Every feature Battleships tracks (43)
FeatureTensorlakeAWS AgentCoreboat
Full VM (own kernel)YesYesYes
Docker insideYesNot publishedYes
Nested virtualizationYesNo documented wayYes
RootYesYesYes
SystemdYesNo documented wayYes
Desktop GUIYesNo documented wayYes
BrowserYesYesYes
Computer-use APIYesYesYes
SSHYesNo documented wayYes
Persistent diskYesYesYes
Pause/resumeYesNo documented wayYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneYesNo documented wayYes
Live fork (no pause)YesNo documented wayYes
Memory forkYesNo 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 inboundNo documented wayNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyNo documented wayNo documented wayYes
Secret proxy for any APINo documented wayNo documented wayYes
Preinstalled agentsNo documented wayNo documented wayYes
Agent harness APINo documented wayNo documented wayYes
MCP serverNo documented wayYesNo documented way
GPUYesYesNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayYesNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCYesYesNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedWith your own setupYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsNot publishedYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionYesNot publishedYes

Performance

TensorlakeNot measured
AWS AgentCoreNot measured
boat28.06 runs/s

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.

ScenarioTensorlake, 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
$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.

ScenarioTensorlakeAWS AgentCoreboat
One coding agent, workdaysNone for this scenario
  • 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 stopsNone for this scenario
  • 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 parallelNone for this scenario
  • 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 usersNone for this scenario
  • different kind of product: code interpreter
None for this scenario
1,000 short jobs at onceNone for this scenario
  • 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 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

More comparisons