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.
An illustration of what /verify/record.html checks. Every record also says, in its own words, what it does not prove.
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.
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.
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.
Image generation
Stable Diffusion 1.5 at 512×512, from your prompt, steps and guidance.
3D rendering
Upload a Blender scene and get your rendered frames back, each from a pinned Blender 4.5 image.
Document OCR
Upload a PDF and get its text back, page by page, each page read on a GPU.
Model evaluation
Score Qwen3-0.6B on your own held-out question set. Large sets are split across GPUs under one Merkle root.
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.
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.
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.
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.
Frequently asked questions
What is Nexido?
How do I check a result?
How are jobs isolated?
Is every result re-run on a second machine?
What GPUs does Nexido run on?
How do I pay? Do I need cryptocurrency?
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.