Tensorlake — Summary

Tensorlake is a serverless compute infrastructure platform combining two products: (1) Sandbox API — Firecracker MicroVM sandboxes with sub-second cold starts, snapshot/clone capabilities, auto-suspend/resume, and near-SSD storage performance; and (2) Orchestrate — a serverless function runtime with @application/@function decorators for deploying distributed agent pipelines with fan-out/fan-in. Both surfaces are cloud-hosted (cloud.tensorlake.ai) with a tensorlake CLI and Python SDK. Performance benchmarks in the README place Tensorlake at 2.45s SQLite completion vs. E2B (3.92s, 1.6x slower) and Daytona (5.51s, 2.2x slower), positioning it as the fastest MicroVM sandbox.

Tensorlake is most similar to e2b from the canonical Phase B Batch 18/33 sandbox seeds (both Firecracker MicroVM, cloud-hosted, sub-second startup), but differentiates via: fastest storage I/O benchmarks, snapshot/clone during runtime (not just at creation), auto-suspend with memory+filesystem preservation, live migration between machines, support for up to 5 million sandboxes per project, and an integrated serverless orchestration runtime.

Tensorlake — Overview

Origin

Tensorlake is a compute infrastructure company. The open-source repo contains the Python/TypeScript SDKs and Rust crates for the Tensorlake cloud service. The CLAUDE.md and AGENTS.md files indicate the team uses Claude Code and OpenAI Codex for internal development.

Philosophy

From the README:

"Tensorlake is a compute infrastructure platform for building agentic applications with sandboxes."

"The Sandbox API creates MicroVM sandboxes which you can use to run agents, or use them as an isolated environment for running tools or LLM generated code."

The explicit performance positioning:

"Fastest Filesystem I/O — Block-based storage achieving near-SSD speeds inside virtual machines. In SQLite benchmarks (2 vCPUs, 4 GB RAM), Tensorlake completes in 2.45s vs Vercel 3.00s (1.2×), E2B 3.92s (1.6×), Modal 4.66s (1.9×), and Daytona 5.51s (2.2×)."

The orchestration philosophy:

"Decorate your entrypoint with @application() and functions with @function(). Each function runs in its own isolated sandbox."

Each function in the serverless runtime runs in its own sandbox — this is the key architectural opinion: isolation-by-default at the function level.

Key Technical Claims

1. Sub-second cold starts via Lattice (dynamic cluster scheduler)
2. Snapshot at any point (not just at creation) with clone-from-snapshot
3. Auto suspend/resume — preserves full memory + filesystem state
4. Live migration between machines with only seconds of pause
5. Up to 5 million sandboxes per project
6. Block-based storage (near-SSD I/O, not network filesystem)

Tensorlake — Architecture

Distribution

• Python: pip install tensorlake
• TypeScript: npm install tensorlake (from typescript/ dir)
• CLI: tensorlake (installed with pip install tensorlake)

Directory Structure

src/
  tensorlake/
    applications/   # @application/@function decorator runtime
    sandbox/        # SandboxClient
    cli/            # tensorlake CLI (Click-based)
    documentai/     # DocumentAI SDK (separate product)
    function_executor/  # gRPC server for function execution
    cloud_client.py
    builder/
    image.py
    utils/
crates/
  cli/              # Rust CLI components
  cloud-sdk/        # Rust cloud SDK
  rust-cloud-sdk-node/  # Node.js bindings
  rust-cloud-sdk-py/    # Python bindings for Rust SDK
typescript/         # TypeScript SDK
examples/           # Reference application examples
reference_app/      # Reference implementation
tests/

Required Runtime

• Python >= 3.10
• Poetry 2.0.0
• TENSORLAKE_API_KEY env var
• uv (optional, for CLI install)
• Go 1.25+ (optional, for building from source)

Install Complexity

Multi-step (pip + API key). CLI: pip install tensorlake or uv tool install tensorlake.

Sandbox Architecture

• Compute: Firecracker MicroVM
• Scheduler: Lattice (dynamic cluster scheduler)
• Storage: Block-based (near-SSD speeds)
• Snapshots: Point-in-time filesystem + memory state
• Network: Per-sandbox isolation

CLI Commands

tensorlake sbx create --image <image>
tensorlake sbx exec <id> -- <cmd>
tensorlake sbx cp <local> <id>:<remote>
tensorlake sbx ssh <id>
tensorlake sbx terminate <id>
tensorlake login
tensorlake deploy <app.py>
tensorlake secrets set <KEY> <value>
tensorlake parse  # DocumentAI

Tensorlake — Components

Sandbox SDK (tensorlake.sandbox)

SandboxClient

• SandboxClient.for_cloud(api_key) — Create client
• client.create_and_connect(image) — Context-managed sandbox
• client.create(image, name) — Named sandbox (reconnectable)
• client.connect(sandbox_id_or_name) — Reconnect to existing
• client.snapshot_and_wait(sandbox_id) — Create snapshot
• client.create(snapshot_id=...) — Restore from snapshot
• client.create_pool(image, warm_containers) — Pre-warm pool
• client.claim(pool_id) — Instant sandbox from pool

Sandbox Instance

• sandbox.run(cmd, args) — Execute command, returns stdout/stderr
• sandbox.write_file(path, content) — Write file to sandbox
• sandbox.read_file(path) — Read file from sandbox
• sandbox.start_process(cmd, args) — Start long-running process

Orchestration SDK (tensorlake.applications)

Decorators

• @application(tags=...) — Mark Python function as orchestration entrypoint
• @function(description, secrets, image) — Mark function for isolated sandbox execution

Image Definition

• Image(base_image, name).run("pip install ...") — Custom sandbox image

Execution

• tl deploy <app.py> — Deploy application
• curl https://api.tensorlake.ai/applications/<name> — HTTP invocation
• SSE streaming support

CLI (tensorlake / tl)

• tensorlake sbx create — Create sandbox
• tensorlake sbx exec — Execute command
• tensorlake sbx cp — Copy file
• tensorlake sbx ssh — Interactive terminal
• tensorlake sbx terminate — Destroy sandbox
• tensorlake login — Authenticate
• tensorlake deploy — Deploy application
• tensorlake secrets set/get — Manage secrets

DocumentAI SDK (separate product)

• Document parsing, extraction, classification
• Separate from sandbox/orchestration products

Tensorlake — Uniqueness

Differs From Seeds

Tensorlake is most similar to e2b from the Phase B Batch 18/33 canonical sandbox seeds (both Firecracker MicroVM, cloud-hosted, SDK-first). Key differentiators: (1) Fastest I/O: block-based storage achieving near-SSD speeds — benchmarked 1.6x faster than E2B in SQLite workloads; (2) Snapshot/clone at runtime (not just at creation) with full memory preservation; (3) Auto-suspend/resume transparent to the SDK; (4) 5 million sandbox scale; (5) Integrated serverless orchestration (@application/@function) that co-deploys the agent pipeline alongside the sandbox infrastructure — not just a sandbox API. The Orchestrate product is the most distinctive differentiator: automatic fan-out with each decorated function running in its own isolated MicroVM is not available in any seed framework.

Positioning

The highest-performance Firecracker MicroVM sandbox platform with an integrated serverless orchestration runtime. Explicitly benchmarks against E2B, Modal, Vercel, and Daytona — positioned as the performance leader in the cloud sandbox space.

Observable Failure Modes

1. Cloud-only: No local deployment or self-hosting — full API dependency
2. Python-primary: The orchestration SDK is Python-only; no JS/Go serverless functions
3. Proprietary image format: tensorlake/ubuntu-minimal — not arbitrary Docker images
4. No pre-built behaviors: Pure infrastructure, zero behavioral opinions
5. gRPC complexity: Function executor uses gRPC with pinned grpcio-tools version (1.60.0) — regenerating stubs is fragile

What Makes It Interesting

The combination of fastest-in-class storage I/O benchmarks + runtime snapshots + serverless fan-out in one platform is not seen in any seed or batch-30 framework. The AGENTS.md reveals the team uses AI agents to build their own product.