One sandbox is a demo; a platform runs thousands. The control plane installs onto your GPU fleet — any NVIDIA cloud, any data centre — and places each agent on a node that fits, keeps it alive, reaps it when idle, and reschedules it when a machine dies. Agents install from a catalog you can cryptographically verify before you run them.
Nodes join, report capacity, and prove they are alive. Placement is capacity-aware and refuses to overcommit.
A host runs the node agent, presents a fleet join token, and reports its cores, memory, and tier. It heartbeats on an interval; miss the window and the scheduler marks it offline.
Each agent lands on the least-loaded node that fits its vCPU, memory, and isolation tier. When the fleet is full, placement is rejected or waits under backpressure — never overcommitted.
Fleet state lives in a shared store, not one process's memory. Reservations are atomic, so two control-plane replicas can't hand out the same last slot, and capacity survives a restart.
Deployed, kept warm, reaped when idle, restarted on failure, evacuated when a node dies — without an operator watching.
Pending, scheduled, running, idle, draining, terminated — with failure and restart. Illegal transitions are rejected, so the fleet's view of an agent can't silently corrupt.
Pre-booted sandboxes per tier so a deploy adopts a ready one instead of paying a cold start. The pool refills itself in the background after each claim.
Idle past its timeout or older than its TTL, an agent is torn down and its capacity returned. If its node stops heartbeating, it is rescheduled onto healthy capacity under its restart policy.
Agents are published signed and versioned. Installing checks the signature and content hash first — you run exactly what the publisher shipped, or you don't run it.
Financial agent with hardware-bound transaction limits and a signed execution trail.
Supply-chain modelling isolated from operator visibility, on tenant-encrypted data.
Hash-chained signed audit trails for automated governance and evidence.
Nodes join with the stand-alone node agent; your code installs a verified agent from the marketplace, or deploys one directly. Either way it is scheduled, kept warm, reaped, and restarted for you.
from terrabox_sdk import TerraboxClient
client = TerraboxClient("https://api.terrabox.example", api_key="tbx_live_...")
# a host joins the fleet (usually run as scripts/node_agent.py on the box):
# POST /api/v1/fleet/nodes/register -> node_id, then heartbeat on interval
# install a SIGNED agent from the marketplace and deploy it, fleet-managed
client.marketplace_install(
"fraud-detector", tenant_id,
require_signed=True, # refuse unsigned / untrusted publishers
deploy=True,
)
# ...or deploy directly: scheduled, warm-started, reaped when idle, restarted on failure
agent = client.deploy_managed_agent(
tenant_id, name="fraud-prod",
template="python",
confidential=True, # place inside an attested TDX node
idle_timeout_seconds=900,
restart_policy="on_failure",
)
client.control_stats() # phase counts, warm pools, live capacity
client.fleet_capacity() # free vCPU / memory / slots across the fleet
client.terminate_managed_agent(agent["agent_id"])The control plane is built and tested. Here's the honest boundary between shipped and roadmap.