Verifiable GPU cloud · beta

The GPU cloud whose results you can check yourself.

Nexido runs AI and rendering jobs on GPUs, each in a gVisor sandbox. Each result comes with a verification record, signed by the machine that ran the job and countersigned with Nexido's key, held in a hardware security module. You check it yourself, in your own browser, without asking us. The price is fixed before the job runs, you pay per output in ordinary currency, and there is no token.

✓ signed and countersigned ✓ gVisor sandbox on every job ✓ price fixed before it runs

An illustration of what /verify/record.html checks. Every record also says, in its own words, what it does not prove.

How the proof works

Run it. It comes back signed. Check it yourself.

Most clouds ask you to trust their logs. Nexido gives you a record you can check without us, with the same code we publish.

Run

Choose a workload and see its price. The server fixes the price and holds it from your wallet before any GPU starts, and you are never charged more than the amount held.

Signed and countersigned

The machine that ran the job signs what it ran and what it produced with its own Ed25519 key. Nexido then countersigns the whole record with a P-256 key kept in Google Cloud's hardware security module, which never leaves it. A record Nexido could not countersign says why.

Check it yourself

Download the record beside your result and open it in /verify/record.html, or run one Node command. Both check every hash and signature on your machine and say plainly what passed, what failed and what could not be checked.

What a record does not prove

A record proves that a machine's key signed the result's hash, and that Nexido issued every other field of it, the pinned software included. It does not prove that the result is correct, that the machine is independent of Nexido or honest, or that the job was re-run elsewhere unless it says so. Nexido's countersignature is as strong as Nexido: it rests on our own registry of machine keys and on who may use our signing key. Each record states its limits itself.

For the two fine-tunes, you can go further: the scripts on the verify page recompute the score from the files you received.

Security, as it runs today

Isolation you can name, evidence you can check.

Each line below describes production as it runs now, not a plan; a measurement made earlier says when.

A gVisor sandbox for every job

Every job runs under gVisor with NVIDIA's nvproxy, the sandbox Google built to run untrusted code. The job talks to gVisor's own kernel, not the host's, and reaches the GPU through a filtered driver interface.

Pinned, tamper-evident software

Every workload runs from a container image pinned by its SHA-256 digest. A machine refuses an image whose digest does not match, and the digest is written into your record.

Clean GPU memory

GPU memory is cleared between jobs. We measured it directly in July 2026, before November's sandbox and driver updates: of 1.57 billion memory slots read back after a job, none held its data.

Signed and countersigned

The machine signs every result with its own key, and Nexido countersigns the record with a key held in a hardware security module. Your proof, checkable without us.

Checked on your machine

The record checker reads your files inside your browser, and its published code sends nothing anywhere; its security policy also blocks fetch, XHR, beacons and form posts (connect-src 'none', form-action 'none'). The same checks run offline as one Node command with no dependencies.

Run it again and compare

Every job runs from a pinned image with its settings and any seed recorded, so it can be run again and compared. For an evaluation, the record also names the result measured across our machines.

What you can run

Six workloads, each with its record.

Billed per output, never per idle hour. The app shows each price, and holds it, before the job runs.

Available now

Image generation

Stable Diffusion 1.5 at 512×512, from your prompt, steps and guidance.

$0.001 per image
Available now

3D rendering

Upload a Blender scene and get your rendered frames back, each from a pinned Blender 4.5 image.

$0.006 per frame
Available now

Document OCR

Upload a PDF and get its text back, page by page, each page read on a GPU.

price shown before you run
Available now

Model evaluation

Score Qwen3-0.6B on your own held-out question set. Large sets are split across GPUs under one Merkle root.

price shown before you run
Available now

Vision fine-tune

DINOv2 ViT-B/14 on your labelled images: a trained classifier, its score on a held-out test split (exact duplicates of training images are reported), and every input image's hash recorded.

price shown before you run
By invitation

LLM fine-tune

Qwen3-4B-Instruct-2507 with LoRA on your conversations: an exact quote to accept first, then the adapter and its scores on held-out validation and test splits.

quote before anything is held
Compared with renting a GPU

Pay for the output, and keep the proof.

An instance from a large cloud is the right tool for many jobs. For a defined workload whose result you need to stand behind, the differences are these.

GPU instance
Nexido
You pay for
Instance time, idle time included
Each output: an image, a frame, a page, a training run
Price known
The rate in advance; the total when the bill arrives
The total, before the job runs, and held
Evidence of what ran
The provider's logs
A record signed by the machine and countersigned with Nexido's HSM key
Checking it
Up to you to build
In your browser, or offline with one Node command
Setup
Drivers, images, scaling
Upload, see the price, run
Payment
Card or invoice
Card, ordinary currency, no token
What runs today

Decentralized by design. Plain about today.

Nexido is designed for a decentralized network of GPUs (a DePIN), in which machines owned by many independent providers are held to the same signed records. Today every GPU on it is operated by Nexido. Here is exactly what runs now.

Live today

In production now.

  • NVIDIA RTX A-series Laptop GPUs on Linux (Ampere, A1000 to A5000), operated by Nexido. Each job goes to a GPU with the memory it needs.
  • Every job in a gVisor sandbox, from a digest-pinned image, with GPU memory cleared between jobs.
  • Records countersigned by Nexido since 7 November 2026, checkable in your browser or offline.
  • Six workloads, from image generation to an LLM fine-tune.
  • Per-output prices in ordinary currency, fixed before the job runs. No token.
  • Beta: payments run in Stripe's test mode, so no real charge is made.
  • Not in place today: job containers are not cut off from the network, and there is no confidential tier, in which even the machine running a job could not read its data.
Questions

Frequently asked questions

What is Nexido?
Nexido is a GPU cloud whose results you can check yourself. It runs AI and rendering jobs on GPUs and returns, with each result, a verification record signed by the machine that ran the job and countersigned with Nexido's key, held in a hardware security module. It is built to run on a decentralized network of GPUs; today every GPU on it is operated by Nexido.
How do I check a result?
Download the verification record from the job page and open it at nexido.ai/verify/record.html, adding the result file if you want its hash checked too. The page checks the hashes, the machine's Ed25519 signature and Nexido's P-256 countersignature inside your own browser and never uploads your files. One Node command, verify-record.mjs, runs the same checks offline. A record Nexido could not countersign says why. For the fine-tunes, a script recomputes the score itself.
How are jobs isolated?
Every job runs inside a gVisor sandbox with NVIDIA's nvproxy, from a container image pinned by its SHA-256 digest; a machine refuses an image whose digest does not match. GPU memory is cleared between jobs, which we last measured directly in July 2026. Today every GPU is operated by Nexido. Two things are not in place today: job containers are not cut off from the network, and there is no confidential tier, in which even the machine running a job could not read its data.
Is every result re-run on a second machine?
Not today. Every job runs from a pinned image with its settings and any seed recorded, so it can be run again and compared; for an evaluation, the record also names the result measured across our machines. Each record states whether its job was re-run.
What GPUs does Nexido run on?
Today, NVIDIA RTX A-series Laptop GPUs (Ampere, A1000 to A5000) on Linux, operated by Nexido. Each job goes to a GPU with the memory it needs.
How do I pay? Do I need cryptocurrency?
No cryptocurrency: you pay in ordinary currency by card, through Stripe, with no token and no crypto wallet. The price of each job is shown and held from your wallet before it runs, and you are never charged more than the amount held. During the beta, payments run in Stripe's test mode and no real charge is made.
Get started

Run a job. Then check it yourself.

Create an account, choose a workload, and see the price before anything runs. Results come with their verification records, ready for the checker.