Drive sealed compute
from the command line.

One surface. Sealed by default.

Cella is sealed, pay-by-the-second compute on confidential GPUs. Everything in this reference talks to a single base URL — there's nothing else to configure, no regions to pick, no console to babysit.

Base URL

All requests go to one host. Paths below are relative to it.

https://api.cella.computer

The sealed-compute model

You don't rent a box and SSH into it. You send a job — an image, a command, and a GPU — and Cella seals it inside a confidential enclave, runs it in the dark, meters it per second, and returns your result. When the run ends the enclave is torn down and nothing is kept.

• Send — POST a job: an OCI/Docker image, a command, and a GPU class.
• Seal — the enclave shuts. No shell, no log stream, no host-side view.
• Run — it runs on a confidential GPU. Only the per-second meter ever leaves the room.
• Return — your result and your bill come back; the room is emptied to nothing.

What you'll need

• An account (one POST, §2) and the fingerprint it returns — your only credential.
• A funded balance in TAO, drawn down per second against the GPU rate (§5).
• curl or the cella SDK (§4). That's the whole toolchain.

Responses & errors

Every endpoint speaks JSON. Successful calls return 200 with the documented body. Missing or invalid auth returns 401; an unfunded balance returns 402; a bad body returns 400. Errors carry a JSON { "error": "…" } message.

Your fingerprint is the key.

There are no passwords and no email. You create an account, and Cella hands back a 32-character fingerprint shown exactly once. That string is your bearer token for every authed call. Store it like a private key — we hold no copy you can recover, and there's no reset.

Create an account from a chosen username. Returns the account id and the fingerprint (shown once).

curl -X POST https://api.cella.computer/v1/account/create \
  -H "Content-Type: application/json" \
  -d '{"username":"ada"}'

{
  "account_id": "acct_7Q2f…",
  "username":   "ada",
  "fingerprint": "f3a9c1e8b7d24056a1c9e2f80b4d6a73",   # your only credential — save it now
  "fp":       "f3a9c1e8",                          # short prefix, safe to display
  "warning":  "This fingerprint is shown once. Store it — it cannot be recovered."
}

Authenticating — the Bearer header

Every authed endpoint expects your fingerprint in the Authorization header as a bearer token. There's no separate login call: the fingerprint is the session. To check it's valid, read your account.

Read the current account — balance in TAO and USD, the live TAO/USD rate, lifetime job count, and creation time. Doubles as a login / token-check.

curl https://api.cella.computer/v1/account \
  -H "Authorization: Bearer $CELLA_FINGERPRINT"

{
  "username":      "ada",
  "balance_tao":   "0.214500000",   # plancks-precise, drawn down per second
  "balance_usd":   "73.42",
  "tao_usd_rate":  "342.30",
  "jobs_total":    18,
  "created_at":    "2026-06-06T09:14:02Z"
}

Funding a balance

Ask for your deposit address, send TAO to it, and the watcher credits your balance. The address is yours for the life of the account; if rails are still warming up the call returns null with a status you can show the user.

Get the TAO deposit address for this account. status is ready when fundable; address is null while rails initialize.

curl -X POST https://api.cella.computer/v1/account/topup-address \
  -H "Authorization: Bearer $CELLA_FINGERPRINT"

{
  "address": "5F3sa2TJAWMqDhXG6jhV4N8ko9SxwGy8TpaNS1repo5EYjQX",
  "status":  "ready"
}

Usage events

Pull a ledger of what you've spent — one event per metered draw. Useful for reconciling the per-second bill against your jobs.

Return the account's usage events (debits, credits, per-job draws).

curl https://api.cella.computer/v1/account/usage \
  -H "Authorization: Bearer $CELLA_FINGERPRINT"

{
  "events": [
    { "type": "job_debit", "job_id": "job_91ac", "seconds": 4.2,
      "cost_tao": "0.0000112", "cost_usd": "0.003839", "at": "2026-06-06T09:31:11Z" },
    { "type": "deposit", "amount_tao": "0.250000000", "at": "2026-06-06T09:14:55Z" }
  ]
}

Send. Seal. Run. Return.

A job is three things: an image, a command, and a gpu. POST it, and Cella seals it into a confidential enclave, runs it in the dark, and meters it per second. Poll for status, or stop it early — you only ever pay for the seconds it computed.

Submit a job. The body takes image, command, and gpu. Returns a job_id and an initial status.

curl -X POST https://api.cella.computer/v1/jobs \
  -H "Authorization: Bearer $CELLA_FINGERPRINT" \
  -H "Content-Type: application/json" \
  -d '{
    "image":   "ghcr.io/you/train:latest",
    "command": "python train.py --epochs 3",
    "gpu":     "h200"
  }'

{
  "job_id": "job_91ac3f",
  "status": "sealing"
}

Job statuses

A job moves through a fixed lifecycle. The meter starts when the door seals and stops the instant the result returns.

List your jobs with their status, GPU, seconds metered, and cost in TAO and USD.

curl https://api.cella.computer/v1/jobs \
  -H "Authorization: Bearer $CELLA_FINGERPRINT"

{
  "jobs": [
    {
      "id":         "job_91ac3f",
      "status":     "returned",
      "gpu":        "h200",
      "image":      "ghcr.io/you/train:latest",
      "command":    "python train.py --epochs 3",
      "seconds":    4.2,
      "cost_tao":   "0.0000112",
      "cost_usd":   "0.003839",
      "created_at": "2026-06-06T09:31:06Z"
    }
  ]
}

Poll one job for live status and the running meter. Same shape as a row in the list. Poll this while status is sealing or running.

curl https://api.cella.computer/v1/jobs/job_91ac3f \
  -H "Authorization: Bearer $CELLA_FINGERPRINT"

Stop a running job. The enclave is torn down immediately; you're billed only for the seconds it computed.

curl -X POST https://api.cella.computer/v1/jobs/job_91ac3f/stop \
  -H "Authorization: Bearer $CELLA_FINGERPRINT"

{
  "id":       "job_91ac3f",
  "status":   "stopped",
  "seconds":  2.6,
  "cost_tao": "0.0000069"
}

Decorate. Run. Done.

The cella Python package wraps the API behind a Modal-style decorator. Point a function at a GPU and call app.run() — the sealing, metering, and teardown are handled for you. Sealed by default, billed per second.

Install

pip install cella

Authenticate by exporting your fingerprint — the SDK reads it from the environment:

export CELLA_FINGERPRINT=f3a9c1e8b7d24056a1c9e2f80b4d6a73

Run a sealed function

Decorate a function with a GPU and call app.run(). The door seals, it runs in the dark, your result returns, and the enclave is torn down to nothing.

import cella

app = cella.App("nightly")

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

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

Deploy a serverless endpoint

Deploy a container as a sealed endpoint; it stays warm and is billed per second while it's live — stop it (cella stop) and you're back to zero. No per-hour minimums.

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 per second while it's live
app.deploy()

One-off from the CLI

For a single run, skip the file. The CLI submits the job and streams back only the meter — never the inside of the room.

# 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

Drive Cella from a Claude Code session.

Cella ships an MCP server — so inside Claude Code (or any MCP client) you can deploy a sealed endpoint, check its status and cost, grab the URL, and stop it, just by asking. Zero dependencies: a single file using Node's built-in stdio + fetch.

Add it

curl -O https://cella.computer/cella-mcp.mjs
claude mcp add cella -s user -e CELLA_FINGERPRINT=YOUR_FINGERPRINT -- node ./cella-mcp.mjs

No fingerprint yet? Add it without one and ask Claude to run cella_create_account — it returns a fingerprint (shown once; it's your only key), which you then set in the config above.

Tools

cella_deploy · cella_status · cella_jobs · cella_stop · cella_account · cella_create_account. There's deliberately no logs tool — honest-host: we can't see into a running job.

In a session

you › deploy vllm/vllm-openai on an h100, port 8000, health /health,
       args --model cognitivecomputations/dolphin-2.6-mistral-7b —
       give me the endpoint and what it costs
cella › deploying… → https://wrk-….serverless.targon.com
        billed per second while up · run cella_stop when done

Real GPUs. Pay per second.

Sealed on Targon's confidential substrate, billed per second of compute used. Scale-to-zero — an idle endpoint costs nothing, and you never pay for a box you aren't using. Rates are per-second; the per-hour figure is just per-second × 3600 for reference.

Scale-to-zero

Both one-off jobs and deployed endpoints are metered only while computing. A serverless function with scaledown="0s" drops to zero between requests, so a deployed endpoint sitting idle costs $0.00. There are no per-hour minimums and no reservation fees.

Settlement

You fund a balance in TAO (§2) and the meter draws against it at the per-second rate, accounted to the planck. balance_usd and each job's cost_usd are computed from the live tao_usd_rate on your account. New keys get a small free credit to clear the "try it" wall.

An honest host: nowhere to look.

This is the whole trust model, said plainly. We don't wave a proof — we built a room with no window and we don't keep what passes through it. Your job runs in a confidential enclave; we keep no logs, hold no keys, and can't see inside.