Tensorlake vs Freestyle
Both can freeze a sandbox with its memory and copy it into warm clones. Tensorlake gives each agent a Firecracker microVM with a desktop, GPUs by request and a bring-your-own-cloud option, while Freestyle gives it a full KVM VM with nested virtualization, coding agent CLIs and a default-deny firewall.
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 microVMs, backed by Firecracker and Cloud Hypervisor, that you create through an API and that boot in a few hundred milliseconds. Named sandboxes suspend when idle and keep their memory and running processes, and you can copy a running sandbox into several warm clones. Around them Tensorlake sells versioned file systems, hosted Git, an orchestration layer 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
Freestyle
Freestyle sells full Linux virtual machines for AI agents, built for long running, complex tasks.
Each Freestyle VM is a KVM virtual machine with its own kernel, booted from an Ubuntu base snapshot with systemd, Docker and coding agent CLIs preinstalled. VMs can be paused with their memory, snapshotted while running, forked and woken by the next request, and every VM starts behind a default-deny firewall. It is built for teams that give each agent or each user its own machine, driven from a TypeScript SDK, a CLI or an API.
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “5th cheapest of 367” means 4 of the other 366 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 | Freestyle: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Tensorlake fits a full software factory and Freestyle is a compromise there; bochka adds nested virtualization, which Tensorlake lacks, on faster CPUs than Freestyle. | 5th cheapest of 367 $1,010 a month | 241st of 367, with limits $3,311 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 9th cheapest of 366 $1,381 a month | 263rd of 366, with limits $4,195 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both fit short code runs well, since both pause with memory and resume warm; bochka's start-rate limits make big bursts a compromise. | 24th cheapest of 345 $250 a month | 40th cheapest of 345 $482 a month | 186th of 345, 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 All three fit a sandbox per user; Freestyle wakes a paused VM on its next request, and bochka adds HTTPS URLs, raw TCP and a per-sandbox usage API. | 5th cheapest of 361 $471 a month | 16th cheapest of 361 $1,358 a month | Cheapest of 361 $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 rollouts at a thousand at a time from warm clones, while Freestyle's Pro plan stops at 400 VMs at once. | Cheapest of 360 $5,637 a month | 107th of 360, with limits $6,600 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 24th cheapest of 364 $506 a month | 53rd cheapest of 364 $1,046 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Freestyle's own docs send sustained heavy CPU work elsewhere, and bochka did about 2.8 times Freestyle's work on the CPU benchmark. | 54th cheapest of 377 $424 a month | 168th of 377, with limits $625 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Freestyle fits a box that stays on all day better than Tensorlake, whose model is built around idle timeouts and suspend. | 185th of 368, with limits $250 a month | 98th cheapest of 368 $151 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Tensorlake ships an XFCE desktop over VNC with screenshot and click calls, bochka streams a 60fps desktop, and on Freestyle you install the desktop yourself. | 9th cheapest of 369 $294 a month | 234th of 369, with limits $940 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 13th cheapest of 367 $250 a month | 257th of 367, with limits $482 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 22nd cheapest of 346 $250 a month | 278th of 346, with limits $482 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 121st of 338, with limits $3,484 a month | 183rd of 338, with limits $6,560 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Tensorlake and bochka fit parallel red teaming fully; Freestyle is a compromise here, and bochka adds raw TCP inbound and nested virtualization. | 4th cheapest of 360 $250 a month | 272nd of 360, with limits $482 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Tensorlake | Freestyle | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | Full KVM VM with its own kernel on bare metal servers that Freestyle says it oversubscribes | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | No published result | 9.64 runs/s | 26.69 runs/s |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Yes, full KVM support | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Docker and systemd | Yes, on the tensorlake/ubuntu-systemd image | Yes; systemd is pid 1 and Docker runs from boot | Yes, with root and systemd |
| Memory pause and resume | Named sandboxes suspend with memory and running processes and restore warm | Pause saves memory and disk; the same processes resume where they left off | Disk saved every minute and on stop; resume boots the machine again |
| Fork a running sandbox | Copy a running or suspended sandbox into N warm clones with memory | Clone a running VM without pausing it; snapshots capture memory and disk | Fork a running sandbox with its disk |
| Idle handling | Idle timeout, 600 s by default, then suspend or terminate | No idle timeout unless you set one; a paused VM wakes on the next request | Time-to-live (1 h by default, changeable or off); a stopped sandbox costs nothing |
| Biggest machine | 16 vCPU / 64 GB on Pro, custom on Enterprise | 32 vCPU / 64 GiB on Pro, 64 / 128 with custom limits | 16 vCPU / 32 GB on the $100 plan and above |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | Guides to install GNOME or Xvfb, VNC and Chromium yourself | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring your own; managed images are plain OS bases | claude, codex, opencode and openclaw preinstalled, driven through exec or a terminal | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Credentials injected at the edge for HTTPS headers, Postgres and S3; the VM must trust the Freestyle CA | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox |
| Inbound traffic | HTTP, WebSocket and gRPC through an authenticated proxy | HTTPS on free style.dev names or your own domain, forward auth, other public protocols | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and a dedicated IP |
| Outbound rules | allow_out and deny_out lists by domain, IP or CIDR, or no internet | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Open internet, no provider-side allowlist; your own firewall as root |
| GPUs and where it runs | GPU sandboxes by request; US and EU, or your own cloud through BYOC | Private GPU sandboxes on Enterprise; regions not listed, docs name San Jose, US | No GPUs; EU only (Germany, Finland, France) with zero data retention |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Freestyle | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Freestyle did 9.64, so bochka finished about 2.8 times as much CPU work in the same time. Tensorlake has no published result on this benchmark, so it cannot be compared on CPU speed. This test does not measure start time: Tensorlake says its default image starts in a few hundred milliseconds and Freestyle advertises about 65 ms.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake has no published run in this suite yet, so there is no like-for-like number to compare.
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.
| Scenario | Tensorlake, a month | Freestyle, a month | bochka, 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 | $27 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $159 · Free | $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 | $2,139 · Pro | $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 | $581 · Pro | $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,305 · Pro · with limits | $2,000 · $2000/mo · with limits |
Tensorlake: Tensorlake Pro is $250 per billing cycle, which includes 25,000 CU of usage, then $0.01 per CU. CPU is billed only while it is actively working, RAM and disk on what you allocate while running, and a suspended sandbox pays snapshot storage; small users can buy prepaid packs from $5 instead.
Freestyle: Freestyle bills per second for the vCPU, RAM and disk allocated to a VM, busy or idle, after monthly allowances of 200 vCPU-hours, 400 GiB-hours of RAM and 60,000 GiB-hours of storage. On Free those allowances are hard stops; Hobby and Pro set a $50 or $500 monthly minimum that counts as usage.
Freestyle: Plans start at $20 a month, and the whole fee becomes usage credit. Running time is billed per second, and a stopped sandbox costs nothing while its disk is kept.
Limits in those scenarios
For 1,000 short jobs at once, Tensorlake Pro fits because it allows 1,000 sandboxes at once, while Freestyle Pro caps at 400 concurrent VMs and bochka queues starts above 90 a minute. Tensorlake's ephemeral sandboxes end after 10 idle minutes by default, and only named ones can suspend. Freestyle has no idle timeout by default, so a VM bills until you pause it, and on Free an agent that runs all month pauses once the allowances run out.
| Scenario | Tensorlake | Freestyle | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite | None that bite | None that bite |
| 50 agents in parallel | None that bite | None that bite | None that bite |
| Sandboxes for your users | None that bite | None that bite | None that bite |
| 1,000 short jobs at once | None that bite |
|
|
Which one should you use?
Use Tensorlake when
you fan out about a thousand short rollouts at once from one warm state, want a desktop ready for computer use, or need GPUs, EU regions or sandboxes in your own cloud account.
- Thousands of warm clones at once. For RL rollouts and evals, Tensorlake Pro runs 1,000 sandboxes at once and copies one warm state into many clones.
- A desktop out of the box. For computer-use agents, Tensorlake ships an XFCE desktop with Firefox and calls for screenshots, mouse and keyboard.
- GPUs, EU and your own cloud. Tensorlake offers GPU sandboxes by request, an EU endpoint, and can run in your own AWS, GCP, Azure or bare-metal account.
Use Freestyle when
your agents need nested virtualization, machines bigger than 16 vCPU, or VMs that sleep with their memory and wake on the next request behind a default-deny firewall.
- Full VMs with nested virtualization. For agents that boot Android emulators or their own VMs, Freestyle exposes KVM, which Tensorlake does not.
- Agents preinstalled and big machines. Freestyle ships claude, codex, opencode and openclaw on PATH, and Pro VMs go up to 32 vCPU / 64 GiB.
- VMs that sleep and wake on traffic. For a VM per user, Freestyle pauses with memory, sets no idle timeout by default and wakes on the next request.
Where bochka fits
If your agents do long work on one machine, like installs, builds, tests, Docker and a browser, look at bochka. It gives each one a full VM with /dev/kvm on faster CPUs, a 60fps desktop, coding agents you drive from outside, and keys that never enter the machine. Tensorlake and Freestyle are ahead on memory snapshots and huge bursts of short jobs.
Emulators and fast builds in one machine
Tensorlake has no /dev/kvm, so Android emulators and VMs do not start. Freestyle has KVM, but did 9.64 runs/s on the CPU benchmark against bochka's 26.69, so every build and test waits almost three times as long.
A desktop and agents you drive from outside
Freestyle makes you install a desktop, VNC and Chromium in your own snapshot. Tensorlake has a desktop but no agents, and on Freestyle you start the CLI through exec and parse its output yourself.
Keys outside and a reachable server
Tensorlake injects secrets into the sandbox the agent controls and only proxies HTTP, WebSocket and gRPC. Freestyle's edge injection needs the VM to trust its CA. bochka's proxy covers any HTTPS API and adds raw TCP on its own IP.
Use bochka when your agents do real work for hours: builds, tests, Docker, emulators, a desktop and a browser, on fast CPUs, with an API to drive the agents inside from outside and keys kept out of the machine. Compare it one to one: bochka vs Tensorlake and bochka vs Freestyle.
Questions people ask
Is Tensorlake cheaper than Freestyle?
It depends on the workload. One coding agent on workdays is $27 a month on Freestyle against $250 on Tensorlake Pro, but 50 agents in parallel is $1,030 on Tensorlake against $2,139 on Freestyle. On bochka those two cost $20 and $317.
Which is faster, Tensorlake or Freestyle?
Freestyle did 9.64 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, and Tensorlake has no published result, so there is no fair CPU comparison. bochka did 26.69 on the same test. For start time, Tensorlake says a few hundred milliseconds and Freestyle advertises about 65 ms.
Can Tensorlake or Freestyle run Docker and Android emulators?
Both run Docker with systemd. Only Freestyle supports nested virtualization, so Android emulators and VMs run there but not on Tensorlake, whose sandboxes set SANDBOX_KVM_AVAILABLE=0. bochka also exposes /dev/kvm.
Do both keep a sandbox's memory when it sleeps?
Yes. Tensorlake's named sandboxes suspend with memory and running processes, and Freestyle pauses a VM with memory and can wake it on the next request. bochka keeps the disk through snapshots every minute and on stop, but a resume boots the machine again.
Which one fits computer-use agents?
Tensorlake ships an XFCE desktop with Firefox over VNC and calls for screenshots, mouse and keyboard. On Freestyle you follow guides to install a desktop, VNC and Chromium yourself. bochka streams a 60fps desktop with Chromium and computer use built in.
Where do Tensorlake and Freestyle run?
Tensorlake runs in the US and the EU, and in your own cloud account through BYOC. Freestyle does not list regions, and its docs name a San Jose, US data center. bochka runs only in the EU (Germany, Finland, France).
Try bochka
Install the CLI, then run bochka new.
Product preview