GPU sandboxes
for agents

Name: Thunder Compute GPU Sandboxes
Availability: LimitedAvailability

Scalable environments for RL tasks, evals, and other agentic workloads

Request access Read the docs

Scale to hundreds of rollouts in seconds

Scale to hundreds of GPUs to run large rollouts in parallel, scale to zero when you're done, billed to the second

UX designed for managing agents at scale

Control sandboxes at scale with the SDK, MCP, REST API or Harbor integration, and view aggregated logs in our console

Built for RL and evals

Give GPUs to your agents

Pay per second for exactly the compute your rollout needs

RL environments

Train agents on tasks that need a GPU, from optimizing CUDA kernels to running ML experiments. Parallel, isolated sandboxes let you collect more rollout data without managing a GPU fleet.

import thunder_sandbox as thunder

runs = []
for _ in range(64):
    box = thunder.Sandbox.create(
        gpu_type=thunder.GPUType.H100, gpu_count=1,
        timeout=900,
    )
    box.wait_until_ready()
    box.upload("rollout.py", "/home/ubuntu/rollout.py")
    run = box.exec("python3", "/home/ubuntu/rollout.py",
                   "--episodes", "64")
    runs.append((box, run))

for box, run in runs:
    run.wait()
    box.terminate()

Evals

Evaluate agents on real GPU workloads, including model inference and CUDA code. Give every task a clean sandbox so runs stay isolated and results are easier to compare.

import thunder_sandbox as thunder

def score(task):
    box = thunder.Sandbox.create(
        gpu_type=thunder.GPUType.H100, gpu_count=1,
        timeout=600, block_network=True,
    )
    box.wait_until_ready()
    box.upload(task, "/home/ubuntu/task", recursive=True)
    run = box.exec("python3", "/home/ubuntu/task/grade.py")
    exit_code = run.wait()
    box.terminate()
    return exit_code

GPU CI/CD

Run CI jobs that need a GPU, from CUDA tests to model inference checks. Catch failures before merging without maintaining GPU runners or paying for them between builds.

import thunder_sandbox as thunder

ci = thunder.Sandbox.create(
    gpu_type=thunder.GPUType.H100, gpu_count=1,
    timeout=1800,
)
ci.wait_until_ready()
ci.upload("repo", "/home/ubuntu/repo", recursive=True)
tests = ci.exec("python3", "-m", "pytest", "-x", "tests/gpu",
                workdir="/home/ubuntu/repo")
exit_code = tests.wait()
ci.terminate()

VMs make better sandboxes

Thunder Compute's GPU sandboxes use Ubuntu microVMs, the gold standard for robust isolation and support

Isolation

Each sandbox runs its own kernel, so agent-written code can’t reach other workloads.

Compatibility

systemd, docker compose and the rest of a normal Linux box work like they do on a server.

A full computer for your agent

For large tasks, a virtual machine is the closest thing to a real computer for your agent.

import thunder_sandbox as thunder

sandbox = thunder.Sandbox.create(
    cpu=4, memory=32, storage=50,
    gpu_type=thunder.GPUType.H100, gpu_count=1,
    timeout=900,
)
sandbox.wait_until_ready()
process = sandbox.exec("nvidia-smi")

● readyttl 15:00

Scale to zero

Non-preemptible environments that scale with your workload

The sandbox lifecycle is closely tied to your task so that you only pay for the seconds you use, without interruption

Never get pre-empted

We use long-lived instances so that sandboxes live for the entire duration of your task

Scale to zero when tasks finish

Pay per second for the exact lifecycle of your task

Per-second pricing

Billed by the second for exactly what you use

The most competitive GPU sandbox prices in the industry

Metered by resource

Separate GPU, vCPU, memory and storage rates

Never preempted

Runs until you stop it or its TTL ends

price per

Thunder Compute$0.000933
Daytona$0.001211
Modal$0.001263

Rates checked Sep 30, 2026

Agent-first

Use agents to manage agents

Use our SDK, MCP server, REST API or Harbor integration to make it simple to manage GPU sandboxes at scale.

MCP server

Claude Code, Cursor or Codex create sandboxes, run commands and stop them on their own

Python SDK & Harbor integration

Create and manage sandboxes with a few lines of Python, or run your workloads through our Harbor integration

agent.py

import thunder_sandbox as thunder

sandbox = thunder.Sandbox.create(
    gpu_type=thunder.GPUType.H100, gpu_count=1,
)
sandbox.wait_until_ready()
process = sandbox.exec("nvidia-smi")

Network control

Firewall rules and other controls to contain your agents

Close the network for evals so the model can’t look answers up. Pick a policy at create time, or switch a running sandbox.

Full outbound internet. Private and cloud metadata networks stay blocked.

sandbox.update_network_policy(
    block_network=False,
)

Allowed · last 60s: 1,284
Refused · last 60s: 37

Sandboxes vs Instances

Pick the right tool for the job

Sandboxes for parallel, automated work. Instances for long-running development.

	Sandboxes	Instances
Lifetime	Minutes to hours, ends on a TTL	Runs until you delete it
Created from	Python SDK, MCP, REST API or Harbor integration	Console, CLI or VS Code
Disk	Wiped when it ends	Kept, with snapshots
Billing	Per second	Per minute
Best for	RL, evals, agents and CI	Development, training, notebooks

Explore pricing →

Give every agent a GPU

Request access to start running lower-cost rollouts today