Computing for Agents

Replayable sandboxes and fluid GPU compute for agents, simulations, and batch workloads.

Every machine is replayable

Numinous Cloud continuously checkpoints memory and disk at the machine's own process events. Rewind to any state, restore it exactly, or fork it into new trials.

Memory + disk, not disk alone
Snapshots preserve full machine state, including memory and filesystem.
Continuous machine history
Checkpoint boundaries follow real process events, so you can rewind to any machine state.
Fork from any checkpoint
Branch a running machine from any saved state and launch many children from the exact same starting point.
Resume, don't rebuild
If a run stops, its machine state is preserved so it can continue from where it left off.

Full environment control

Control what the machine can reach, what runs inside it, what it starts with, and what survives after it stops.

Allow, deny, and pin exactly what a sandbox can reach. Policy is enforced by the infrastructure, not trusted to the workload.
DNS + proxy + kernel enforcement
Run Docker-in-Docker, Compose, or Kubernetes inside the sandbox. Checkpointing, replay, networking, and storage still apply to everything running inside.
dind · compose · k3s
Templates package the machine you want to start from. Shared ROMs mount large immutable files into many sandboxes without copying them into each one.
templates from above, ROMs from below
Attach persistent writable storage independently of the sandbox lifecycle. Destroy the machine; the volume does not move.
single-attach, billed by GiB-hour

egress policy

internet

sandboxNuminous microVMVM 02sandbox A

docker-in-dockerdocker composekubernetes

containers

apptestbuild

no orchestrator

dockerdruntime

checkpoint #31 · 3 layers · everything inside included

template python-agent-v14

VM 01

VM 03

shared ROM 42.8 GiB · read only

model weightsdatasetstoolchains

volume_42 /workspace0 B

src/214 MiB

node_modules/1.2 GiB

.cache/3.8 GiB

results/9.6 GiB

attachednonesingle-attach

sandbox B

sandbox C

destroyeddestroyedrunning

Built-in LLM usage limit depletion handling

When the model provider says you are out of credits, the run does not die. The machine is checkpointed, suspended at no compute cost, and resumed from the exact same state when credit comes back.

01run

>fix the failing test in tests/test_parser.py

$pytest tests/test_parser.py -q

FAILED test_parse_nested 1 failed, 11 passed

$edit src/parser.py +14 -3

$pytest tests/test_parser.py -q

!error 429 insufficient_quota: out of credits

agent trajectory · 0 messages

02snapshot

checkpoint#47

memory3.2 GiB

processes187

disk4.3 GiB

trajectory6 messages

signal credit_exhausted · job.pause()

03wait

00:00

machinesuspended

compute$0.00/hr

statekept

credit_restored

waiting for credit_restored

04resume

>fix the failing test in tests/test_parser.py

$pytest tests/test_parser.py -q

FAILED test_parse_nested 1 failed, 11 passed

$edit src/parser.py +14 -3

$pytest tests/test_parser.py -q

12 passed in 0.41s

$git commit -am "parser: handle nested lists"

[main 4f1c2e9] 1 file changed, 14 insertions

$git push origin main

>next: add a regression test for issue #212

$edit tests/test_parser.py +22 -0

job.resume() · 38 ms · same machine state

Don't lose runs to LLM API hiccups.

Efficient GPU sandboxes, no wasted compute

A whole card when you need one, a fraction when you don't, or a deadline and we pack the work in. Pay for the GPU you use, not the card you don't.

A quarter of the card, all the time. A persistent quarter, half, or any share of a card, with a hard cap on compute and memory. Same sandbox, same API.
```
nc = Numinous()
sb = nc.sandboxes.create(
    image="pytorch/pytorch:2.4.0-cuda12.4-runtime",
    gpu=1, gpu_type="H100",
    gpu_mode="shared", gpu_fraction=0.25,
)  # labels["numinous.gpu_granted_fraction"] == "0.25"
```
best for
agents, smaller models, inference servers, dev environments
pricing
your fraction of $3.89 per H100-hour, billed by occupancy
The whole card, a guaranteed share of every hour. The card is virtualized. You are guaranteed fifteen minutes of it every hour, taken whenever your work needs them, in bursts of any length, at full speed. Other tenants fill the gaps.
```
nc = Numinous()
sb = nc.sandboxes.create(
    image="pytorch/pytorch:2.4.0-cuda12.4-runtime",
    gpu=1, gpu_type="H100",
    gpu_mode="shared",   # a guaranteed share of the card's time
)
```
best for
agents that burst, evals, anything idle most of the hour
pricing
the card rate for the minutes you hold it
Trade time for lower compute costs. Submit jobs and a deadline. We pack them into idle capacity across the fleet and finish in time, for less than a card per job.
```
nc = Numinous()
batch = nc.gpu.batch(
    gpu_type="H100",
    deadline="24h",
)
batch.map(run_eval, tasks)
```
best for
evals, simulations, batch inference, offline workloads
pricing
per GPU-hour, lower the longer the deadline
A GPU when you need one. A whole GPU on demand, an H100 for example, checkpointed like every other machine here.
```
nc = Numinous()
sb = nc.sandboxes.create(
    image="pytorch/pytorch:2.4.0-cuda12.4-runtime",
    gpu=1, gpu_type="H100",
    gpu_mode="dedicated",
)
```
best for
training, inference, development, dedicated workloads
pricing
$3.89 per H100-hour, billed per second while it runs

Fleet cost, throttled by design

Left alone, a fleet grows to whatever the harness asks for and the bill grows with it. Each limit is a gate or a throttle on the fleet, and you watch the number come down as they switch on.

from numinous import Numinousnc = Numinous() nc.limits.set(    max_concurrent=40,    monthly_budget_usd=2000,    budget_mode="hard",) for task in tasks:    nc.sandboxes.create(        image="python:3.12", vcpu=4, mem_gib=8,        auto_suspend_idle_seconds=300,        ttl_seconds=7200,        wait=False,    )

$0.06 per vCPU-hour, 2 GiB included. $3.89 per H100-hour. Nothing preemptible.

Billed per second, no commitment. The same 2 vCPU / 4 GiB trial: Modal $0.238/hr, Daytona $0.166/hr, Numinous $0.12/hr. Every trial is checkpointed at every tool call, so when a machine dies the trial pauses and resumes; it does not fail. Committed capacity for teams that know their shape: talk to us.

01On-demand
The default
Ask for a machine, get a machine, pay list rate per second while it runs. If capacity is short you get a typed refusal with an ETA, and the SDK can wait it out for you.
```
sb = nc.sandboxes.create(
    image="python:3.12",
    vcpu=4, mem_gib=8,
    retry_admission_sec=300,
)
```
$0.24/hr per 4 vCPU / 8 GiB, no commitment
02Committed
A lower rate for the fleet you know you run
Reserve a shape and a count for a term. We keep that hardware for you; every create of that shape draws from it at the committed rate, with no change to the create call.
```
nc.capacity.reserve(
    vcpu=4, mem_gib=8, count=40,
    duration_minutes=43200,
    committed=True,
)
```
committed rates by agreement; talk to us
03Committed + queue
Keep pushing work; it fills the slots as they free
Submit as many trials as you like. The first forty run on committed capacity; the rest wait in the queue and start as slots free. The bill stays flat.
```
nc.batches.submit(
    name="eval-2026-09",
    trials=[spec(t) for t in tasks],
)
```
queue depth is unbounded; cost is the committed capacity
04Burst
When one cannot wait
A plain create skips the queue. Beyond your committed slots it lands on on-demand capacity at list rate, right now, and the queue keeps draining behind it.
```
sb = nc.sandboxes.create(
    image="python:3.12",
    vcpu=4, mem_gib=8,
)
```
committed capacity stays at its rate; the burst pays $0.24 while it runs

Built for agents, and for the people who run them

Self-serve onboarding for an LLM, a CLI and SDK with one surface, failures you can branch on, states you can wait on, and limits you set yourself.

01Skills, CLI, SDK
An agent can onboard itself
One install. The CLI prints its own skill file, the reference an agent loads into context to drive it, and the SDK is the same surface from Python.
```
pip install numinous
numinous whoami
numinous skill  # agent reference
```
numinous boot · exec · snapshot · fork · steps · network · export
02Typed failures
No guessing from stderr
Every failure carries a cause, whether it is retryable, and whose fault it is. Provider faults are never billed, by contract, so a retry costs you nothing.
```
try:
    nc.sandboxes.create(image=img)
except NuminousError as e:
    e.cause        # "provider_capacity"
    e.retryable    # True
    e.is_provider_fault  # $0 billed
```
user_oom · user_timeout · policy_killed_ttl · provider_capacity · ...
03Status for every state
You always know where the machine is
Creating, running, suspended, terminated, failed: each is a state you can wait on and an event you can read. A trial that goes quiet is labelled stalled, with the evidence.
```
nc.sandboxes.wait(id, until="running")
for ev in nc.sandboxes.events(id):
    print(ev["kind"], ev["detail"])
```
creating → running → suspended → terminated | failed
04Limits on your terms
Caps you set, enforced at admission
Concurrency, vCPU, memory, GPUs, start rate, daily and monthly budget. Hard means refused with a typed 429; warn means told and allowed. Queue at the gate for as long as you say.
```
nc.limits.set(
    max_concurrent=200,
    monthly_budget_usd=5000,
    budget_mode="hard",
    admission_wait_sec=90,
)
```
org_quota is retryable when a slot will free; a budget cap is not

Pricing

Per second. Nothing preemptible, no spot tier. Prepaid credits. Committed rates are half of on-demand and start at a $25k monthly floor.

sandbox	memory	on-demand	committed
1 vCPU	2 GiB	$0.06/hr	$0.03/hr
2 vCPU	4 GiB	$0.12/hr	$0.06/hr
4 vCPU	8 GiB	$0.24/hr	$0.12/hr
8 vCPU	16 GiB	$0.48/hr	$0.24/hr
16 vCPU	32 GiB	$0.96/hr	$0.48/hr
32 vCPU	64 GiB	$1.92/hr	$0.96/hr
64 vCPU	128 GiB	$3.84/hr	$1.92/hr

H100, whole card$3.69 / hrfractional and time-shared at your share of this rate
RTX 6000, whole card$2.89 / hrfractional and time-shared at your share of this rate
Suspended state$0.12 / GiB-monthinstead of compute while a machine sleeps
Snapshots, templates, ROMs$0.08 / GiB-monthcontent-addressed and deduplicated
Persistent volumes$0.10 / GiB-monthprovisioned size, sandbox or GPU kind
Artifact egress$0.02 / GiBfree to your own in-region S3
Provider faults$0seconds lost to provider_* causes are never billed

Start with a sandbox. Bring your agent.

Prepaid credits, no minimum. Committed capacity when you know the shape of your fleet.

Start nowTalk to us about committed

Computing for Agents

Memory + disk, not disk alone

Continuous machine history

Fork from any checkpoint

Resume, don't rebuild

The default

A lower rate for the fleet you know you run

Keep pushing work; it fills the slots as they free

When one cannot wait

An agent can onboard itself

No guessing from stderr

You always know where the machine is

Caps you set, enforced at admission

Start with a sandbox. Bring your agent.