Sandbox-native cloud for agents.
Stateful compute for durable agentic loops + isolated tool/code execution. Pause mid-run, resume hours later in the exact state you left.
Free tier included. No credit card required.
import { Sandbox } from "tensorlake";
async function main() {
const sbx = await Sandbox.create();
const result = await sbx.run("/bin/sh", { args: ["-c", "npm install && npm run build"] });
console.log(result.stdout);
}
main();
Give your agent a computer.
harness · tool
Run persistent sandboxes that give an agent its own computer, or spin up ephemeral ones to isolate each tool call.
Give the agent its own filesystem, shell, packages, and processes instead of sharing the app server runtime.
Sandboxes sleep on inactivity and wake instantly when invoked — sessions can run for hours or days.
Compile code, run databases, process large files. Bring any Linux stack.
Execute LLM-generated code inside secure microVMs, isolated from the harness.
Suspend, resume, and copy a whole machine.
suspend · resume · fork
Pause on idle. Wake in a second.
Freeze a sandbox — memory, processes, and filesystem intact — and the meter stops. Resume by name in about a second, or let it wake automatically the moment a request or connection comes in.
$ tl sbx suspend my-dev✓ suspended · meter stopped · state on disk$ tl sbx resume my-dev✓ resumed in 0.9s · pid 4127 still alive↺ auto-wakes on the next request or connection
Fork a running VM, memory and all.
Clone a live sandbox — its memory and filesystem copied whole — then run the copies. A fork of the entire machine: build a base once, then fan out identical copies to run many CI jobs in parallel.
$ tl sbx copy build-base --count 8✓ forked 8 copies (memory + filesystem)build-base-01 … build-base-08 running$ tl sbx ls --tag build-base8 sandboxes · 0 cold starts · ready for jobs
The fastest sandbox file system.
fio · sqlite · p50
SQLite benchmark — 2 vCPU, 4 GB RAM, 100k inserts
View benchmark on GitHub→In our published SQLite benchmark across Tensorlake, Vercel, E2B, Daytona, and Modal, Tensorlake was the fastest across default, fsync, and large-dataset runs. Benchmark setup: 2 vCPU / ~4 GB sandboxes, 3 runs.
Harbor integration for agents evals and RL rollouts.
terminal-bench@2.0
Prepare once, clone many
Snapshot a warmed environment — deps, weights, data — and clone it thousands of times in parallel. Pay once for setup.
Known starting state
Files, packages, processes and seeds are reproducible across every rollout. No flakey drift across workers.
Scale rollouts & evals
Fan out to 10k+ concurrent environments. Checkpoint at any step, resume at any step, write to object storage.
# from an OCI image harbor run --env tensorlake \ --ek use_oci_image_build=true \ --dataset terminal-bench@2.0 \ --agent claude-code \ --model anthropic/claude-opus-4-8 \ --ae ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY # from a snapshot harbor run --env tensorlake \ --ek snapshot_id=snap_abc123 \ --dataset terminal-bench@2.0 \ --agent claude-code \ --model anthropic/claude-opus-4-8
terminal-bench • oracle ┏━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━┓ ┃ Trials ┃ Exceptions ┃ Mean ┃ ┡━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━┩ │ 89 │ 0 │ 0.921 │ └────────┴────────────┴───────┘ ┏━━━━━━━━┳━━━━━━━┓ ┃ Reward ┃ Count ┃ ┡━━━━━━━━╇━━━━━━━┩ │ 0.0 │ 7 │ │ 1.0 │ 82 │ └────────┴───────┘ Job Info Total runtime: 20m 54s
Sandbox-native orchestration for agents.
endpoints · durability
Once sandbox usage turns into a real application, Orchestrate coordinates it.
The layer that adds application endpoints, durability, fan-out, retries, and application-level observability on top of sandbox execution.
Expose sandbox-backed workflows as callable applications instead of stitching together raw VM APIs.
Predictable throughput means fresh sessions spin up immediately, even when a thousand others are mid-task.
Dormant sandboxes resume on incoming traffic. Every session gets its own sandbox so nothing leaks across runs.
Durable primitives for long-running agentic flows. Application observability baked in.
# PDF → Markdown with Claude
from tensorlake.applications import application, function
from anthropic import Anthropic
claude = Anthropic()
@application()
@function()
def to_markdown(pdf_url: str) -> str:
pdf = fetch(pdf_url)
msg = claude.messages.create(
model="claude-sonnet-4-5",
max_tokens=8192,
messages=[{"role": "user", "content": [
{"type": "document", "source": pdf},
{"type": "text", "text": "Convert to clean Markdown."},
]}],
)
return msg.content[0].text
SSH in from any machine. The sandbox is your dev environment too.
ssh · vs code · pty
A named sandbox isn't only an execution surface — it's a portable cloud workstation. Register your key once, then ssh in, or open it in VS Code, Cursor, or JetBrains Gateway over Remote-SSH. scp, rsync, and full port-forwarding all ride the same connection.
- PORTABLE IDENTITY
- Connect to the same sandbox id from any laptop. Which region or host the VM lives on is the platform's problem — not yours.
- SUSPEND ON IDLE
- Named sandboxes auto-suspend after the idle timeout. The clock pauses while you're connected, so you only pay while you work.
- STATE SURVIVES RESUME
- Filesystem, memory, running processes, tmux sessions and ~/.vscode-server are exactly where you left them — resume by name, weeks later.
- PTY OVER WEBSOCKET
- Building a browser terminal? Drive a programmatic PTY over WebSocket, disconnect, and reattach to the same session by token.
Used by engineering teams shipping agents in production.
n = 14 interviews
Tensorlake let us ship faster and stay reliable from day one. Complex stateful AI workloads that used to require serious infra engineering are now just long-running functions. As we scale, that means we can stay lean — building product, not managing infrastructure.
At SIXT, we're building AI-powered experiences for millions of customers while managing the complexity of enterprise-scale data. Tensorlake gives us the foundation we need — reliable document ingestion that runs securely in our VPC to power our generative AI initiatives.
Tensorlake enabled us to avoid building and operating an in-house OCR pipeline by providing a robust, scalable OCR and document ingestion layer with excellent accuracy and feature coverage.
With Tensorlake, we've been able to handle complex document parsing and data formats that many other providers don't support natively, at a throughput that significantly improves our application's UX. The team's responsiveness stands out.
Run it in our cloud — or yours.
SOC 2 · HIPAA
Bring Tensorlake into your cloud.
Run sandboxes and applications inside your own AWS / GCP / Azure account when you need lower egress, stricter network boundaries, dedicated capacity or more predictable performance.
Security built for agentic workflows.
LLM-generated code runs in isolated VMs, not shared processes. Full audit trails, per-project data boundaries, and compliance for regulated workloads.