CELLA CONSOLE

sealed compute · bring-up

Cella Console · v1

Compute
you can't
see into.

This page is the product. Drive a sealed-compute console — send a job, watch the door seal, run it on confidential GPUs by the second. We keep nothing, and we can't look in.

Run a job ↵ How it works

cella ❯ control deck idle

Console ready. Type a job and seal it — or tap a sample below.

sealed enclave view in · denied

no view inside the door is shut — including to us

cost · this job

$0.000000

elapsed

0.0s

rate · gpu

$0.000914

gpu H200

logs written 0

util —

seen by us nothing

01 The life of a sealed job

Four moves. Nothing kept after.

Every job runs the same lifecycle. You only ever touch the two ends — what you send, and what comes back. The middle is dark to everyone, us included.

01 — SEND

Send

Push any container or script through one sealed channel. Inference, a training run, a batch job — anything that runs in Docker.

one channel in · encrypted

02 — SEAL

Seal

The enclave shuts. No console, no log stream, no shell, no way in. That door is closed to us the same as to everyone else.

no shell · no log · no key held

03 — RUN

Run

It runs in the dark on confidential GPUs. Only the per-second meter ever leaves the room. What runs inside is noise to outside observers.

confidential GPU · per-second meter

04 — RETURN

Return

Your output and your bill come back. The enclave is torn down to nothing. Kept inside afterward: nothing. Logs written: zero.

result + bill out · room emptied

02 Why sealed

An honest host:
nowhere to look.

We don't wave a proof. We just built a room with no window — and we don't keep what passes through it. That's the whole posture, said plainly.

We can't see inside.

Your workload runs in a confidential enclave. There's no shell for us to open and no log stream for us to read. The view in is denied to the host.

We keep no logs.

Nothing about your job is written down and retained. When the run ends, the room is torn down and there's nothing left to hand over, leak, or subpoena.

We hold no keys.

We don't custody what's yours. The host is a runtime, not a vault — there's no master key sitting here waiting to be misused.

No proof to wave. // by design

This is a posture, not a certificate. If your threat model demands a per-job cryptographic attestation, run it yourself — we won't pretend to be something we're not.

what leaves the room · what stays

your resultreturned to you

the per-second billreturned to you

logs of your jobnever written

a copy of your datanot retained

a host's-eye viewno window exists

03 Live confidential capacity

Real GPUs. Pay per second.

Sealed by default on Targon's confidential substrate. Scale-to-zero — you never pay for an idle box. Rates below are live; the meter in the console runs against the H200 figure.

inventory ❯ confidentiallive

GPU

demand

$ / hour

$ / second

Capacity figures are live confidential inventory. Billing is per-second of compute used; idle time is never billed.

04 The SDK

Decorate. Run. Done.

A Modal-style Python SDK. Point a function at a confidential GPU and call app.run() — the sealing, metering and teardown are handled for you.

train.py

infer.py

cli

import cella

app = cella.App("nightly")

@app.function(gpu="h200")   # sealed · per-second · scale-to-zero
def train(d):
    return finetune("mistral-7b", d)

if __name__ == "__main__":
    app.run()        # door seals · runs in the dark · result returns

import cella

app = cella.App("serve")

@app.function(gpu="h100", scaledown="0s")
def generate(prompt):
    return model.complete(prompt)   # runs inside the sealed enclave

# deploy once, billed only while a request is in flight
app.deploy()

# run a one-off job, billed by the second
$ cella run ./train.py --gpu h200

  › bundling job ............ ok
  › addressing enclave ...... ok
  › pushing through seal .... ok
  › door sealed · running in the dark
  › ran 4.2s · $0.003839 · kept inside: nothing

pip install cella · python 3.10+

05 Straight answers

The honest fine print.

Can you actually not see my job?

Right. The workload runs inside a confidential enclave with no shell, no log stream, and no host-side view. There's no window for us to peek through, and nothing about the run is written down to read later. We describe this as sealed — not as a proof you can verify, because we don't hand you one.

So where's the proof — the attestation?

There isn't one, and we won't pretend otherwise. Cella is an honest host: nowhere for us to look, nothing kept after. We deliberately don't market "verifiable" or "attested." If your threat model needs a per-job cryptographic certificate, that's a different product — run it yourself.

How does per-second billing work?

You're billed only for the seconds your job is actually computing, against the live GPU rate. The meter starts when the door seals and stops the instant the result returns. Idle time is never billed — the enclave scales to zero between jobs.

What can I run?

Anything that runs in a container — a fine-tune, batch inference, a render, a data job. The SDK wraps it as a sealed function; the CLI runs one-offs. Choose a GPU (or CPU) with one argument and Cella handles sealing, metering and teardown.

What happens to my data after the run?

The enclave is torn down to nothing. There's no retained copy of your inputs, no cached output, and zero logs. When the run ends, there is nothing left here to leak, sell, or hand over.

How do I pay?

Crypto-native settlement, by the second. New keys get a small free credit to clear the "try it" wall. You fund a balance and the meter draws against it — no per-hour minimums and no idle charges.

Your work goes where no one follows.

A room we can't walk into, torn down when you're done. Pay by the second for only the seconds you used.

Drive the console ↑ Get started