Tensorlake vs GitHub Codespaces
Tensorlake is a sandbox API for agents: microVMs that boot in a few hundred milliseconds, sleep with their memory and copy into warm clones. GitHub Codespaces is a dev environment for people: a dev container per GitHub repository, opened in VS Code or the browser, that stops after 12 hours at most.
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
GitHub Codespaces
GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.
Codespaces is a different kind of product from bochka: a dev environment for people working on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config, running on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.
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 | GitHub Codespaces: 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 software factory fully while Codespaces is a compromise because of its 12-hour stop; bochka adds /dev/kvm and preinstalled coding agents. | 5th cheapest of 367 $1,010 a month | 274th of 367, with limits $4,618 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant does not fit Codespaces, which stops after 12 hours at most; Tensorlake Pro has no session cap, and bochka keeps the machine on with no idle timer. | 9th cheapest of 366 $1,381 a month | 309th of 366, with limits $6,970 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 | 24th cheapest of 345 $250 a month | 288th of 345, with limits $619 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 Tensorlake creates a sandbox per user through an API; Codespaces are created for GitHub users on a repository, so handing them to your own users is a compromise. | 5th cheapest of 361 $471 a month | 281st of 361, with limits $1,964 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 RL rollouts, with 1,000 sandboxes at once on Pro and warm clones from one state, while Codespaces does not publish how many can run at once. | Cheapest of 360 $5,637 a month | 282nd of 360, with limits $9,489 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 | 295th of 364, with limits $1,519 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 Both can run fresh build machines, but Codespaces starts each one from a repo or prebuild with no fork, and bochka's hosts are the fastest measured on the CPU benchmark. | 54th cheapest of 377 $424 a month | 314th of 377, with limits $909 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither is a full fit for a 24/7 box: Tensorlake suspends idle sandboxes and Codespaces stops at 12 hours, while bochka runs until you stop it. | 185th of 368, with limits $250 a month | 130th of 368, with limits $270 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 has an XFCE desktop over VNC and Codespaces has no graphical desktop; bochka streams a 60fps desktop with Chromium. | 9th cheapest of 369 $294 a month | 267th of 369, with limits $1,367 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 | 275th of 367, with limits $678 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 | 310th of 346, with limits $922 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 | 280th of 338, with limits $18,637 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 can copy one prepared sandbox into many, while every codespace is created again from the repository. | 4th cheapest of 360 $250 a month | 267th of 360, with limits $445 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 | GitHub Codespaces | bochka |
|---|---|---|---|
| What it is | A sandbox API for agents, evals and RL rollouts | A cloud dev environment for people working on a GitHub repository | A sandbox API for agents, with full VMs you drive from code |
| Isolation | Firecracker and Cloud Hypervisor microVMs with their own kernel; GPU sandboxes use gVisor | A Docker container on its own newly built VM, with its own virtual network | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| How long it runs | No session cap on Pro; idle timeout of 600 s by default, then suspend or terminate | Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use | Runs until you stop it; no session cap on paid plans and no idle timer |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | /dev/kvm and nested virtualization are not documented | Yes, /dev/kvm inside, so Android emulators and VMs run |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Yes, in the dev container, with sudo | Yes, with root and systemd on every machine |
| Keeping state | Named sandboxes suspend with memory and running processes and restore warm | Files are kept when it stops, no memory; stopped codespaces are deleted after 30 days by default | Disk snapshots every minute and on stop; a stopped sandbox costs nothing; resume reboots |
| Copy a running machine | Copy a running or suspended sandbox into N warm clones with memory | No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild | Fork a running sandbox into copies with its disk |
| Setting up the environment | Managed OS images or your own OCI image | Dev container config in the repository, with prebuilds built by GitHub Actions | Named snapshots as templates, shareable by code; no Dockerfile builds |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | VS Code in the browser or on your machine, JupyterLab and a terminal; no graphical desktop | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | You bring and run your own agent | GitHub Copilot as a VS Code extension; other agents you install yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Secrets are copied into the codespace as environment variables | AI credentials proxy for model providers and any HTTPS API: real keys never enter the sandbox |
| Reaching the machine | HTTP, WebSocket and gRPC through an authenticated proxy on exposed ports | A URL per forwarded port, private, organization or public; SSH tunnels; no public IP | 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 at all | Open internet; GitHub says there is no way to restrict it | Open internet; no provider-side allowlist, you set your own firewall as root |
| GPUs and where it runs | GPU sandboxes by request; US and EU, or your own cloud through BYOC | No GPU machines; US East, US West, Europe West and Southeast Asia | No GPUs; EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Tensorlake | GitHub Codespaces | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | 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 | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | 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 | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Neither Tensorlake nor GitHub Codespaces has a result on the hpc-sandbox-benchmarks Node.js build-and-test loop we use, so there is no comparable CPU measurement between them. bochka scores 26.69 runs/s on that loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake and GitHub Codespaces have 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 | GitHub Codespaces, 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 | $51 · Personal account: GitHub Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $270 · Personal account: GitHub Free · 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 | $3,019 · Personal account: GitHub Free | $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 | $850 · Personal account: GitHub Free · 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,889 · Personal account: GitHub Free · with limits | $2,000 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes $250 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.
GitHub Codespaces: Codespaces bills $0.09 per core-hour for the whole time a codespace is active, plus $0.07 per GB-month of storage while it exists, stopped too. There is no 4-core machine with 8 GB, so 4 vCPU / 8 GB jobs are priced on the 4-core 16 GB machine; personal accounts get a free monthly quota and organizations do not.
GitHub Codespaces: You pick a monthly plan from $20, and the whole fee becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Codespaces stops every codespace after 12 hours at most, so it does not fit one agent running all month, and GitHub does not publish how many can run at once, so 300 user sandboxes and 1,000 short jobs show as not confirmed. Tensorlake Pro allows 1,000 sandboxes at once, so it is the only one of the three that fits 1,000 short jobs at once, at $1,127 a month. bochka's limit is how fast new machines start: bursts above 90 starts a minute are queued, so that burst does not fit even on the $2,000 plan.
| Scenario | Tensorlake | GitHub Codespaces | 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 |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users | None that bite |
| None that bite |
| 1,000 short jobs at once | None that bite |
|
|
Which one should you use?
Use Tensorlake when
your code fans out many short agent runs, evals or RL rollouts from one warm state, or you need GPUs, outbound rules or sandboxes in your own cloud.
- Memory snapshots and warm clones. Useful when an agent must pick up mid-process: Tensorlake saves a sandbox's memory and copies it into warm clones.
- Built for big fan-outs from code. Useful for RL rollouts and evals: Tensorlake Pro runs 1,000 sandboxes at once, created through an API in a few hundred milliseconds.
- GPUs, outbound rules and your own cloud. Tensorlake offers GPU sandboxes by request, per-sandbox outbound allow and deny lists, and can run in your own cloud account.
Use GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, in the US, EU or Asia.
- Built into GitHub. Useful if your team lives on GitHub: open a codespace from any repo, branch or pull request, with the dev container ready.
- Cheap for occasional personal work. A GitHub Free account includes 120 core-hours a month, and one agent on workdays prices at $51 against Tensorlake Pro's $250.
- Regions in the US and Asia. Useful if your developers sit far from the EU: codespaces run in US East, US West, Europe West and Southeast Asia.
Where bochka fits
If what you are really running is coding agents that work for hours, neither option is a full fit: Tensorlake has no /dev/kvm and leaves the agent to you, and Codespaces stops every 12 hours. bochka gives each agent a full VM with /dev/kvm, Docker, systemd and a desktop, with coding agents built in and keys kept outside the machine.
Run emulators and VMs inside
Tensorlake sandboxes report no KVM and GitHub documents no /dev/kvm in a codespace, so an agent that tests an Android app or boots a VM has nowhere to run it. Every bochka machine has /dev/kvm.
Keep working past 12 hours
A codespace stops after 12 hours even while in use, so a long agent task needs a restart script and loses its processes. Tensorlake ends idle ephemeral sandboxes after 10 minutes by default. bochka runs until you stop it.
Agents built in, keys kept out
On both, you install the agent yourself and its API keys sit inside the machine as injected secrets or environment variables, where code the agent runs can read them. bochka preinstalls Claude Code, Codex and OpenCode and keeps real keys in a proxy outside.
Use bochka when your agents work for hours or days: full VMs with /dev/kvm, Docker and a desktop, coding agents built in with keys kept outside, and machines that keep their work and fork while running. Compare it one to one: bochka vs Tensorlake and bochka vs GitHub Codespaces.
Questions people ask
Is Tensorlake cheaper than GitHub Codespaces?
It depends on the size. One coding agent on workdays is $51 a month on Codespaces and $250 on Tensorlake Pro, but 50 agents in parallel is $1,030 on Tensorlake against $3,019 on Codespaces. bochka prices those at $20 and $317.
Which is faster, Tensorlake or GitHub Codespaces?
Neither has a result on the CPU benchmark we use, so we cannot compare their speed. Tensorlake says its default image starts in a few hundred milliseconds, while a codespace builds a dev container on a new VM. bochka scores 26.69 runs/s on that benchmark.
Can I run an AI agent 24/7 on Tensorlake or Codespaces?
On Codespaces, not without restarts: every codespace stops after 12 hours, even while in use. Tensorlake Pro has no session cap, but idle sandboxes suspend or end after 600 seconds by default. A bochka sandbox runs until you stop it, with no session cap on paid plans.
Can Tensorlake and Codespaces run Docker?
Yes, both: Tensorlake on its ubuntu-systemd image and Codespaces inside the dev container with sudo. Neither offers /dev/kvm for emulators or VMs. Every bochka machine has Docker, systemd and /dev/kvm.
Which one keeps memory when a machine sleeps?
Tensorlake does: named sandboxes suspend with memory and running processes and can be copied into warm clones. Codespaces keeps only files when it stops. bochka keeps the disk through snapshots every minute and on stop, and a resume boots the machine again.
Where do Tensorlake, Codespaces and bochka run?
Tensorlake runs in the US and the EU, or in your own cloud account through BYOC. Codespaces runs in US East, US West, Europe West and Southeast Asia. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview