riggrade

RigGrade is an independent, single-operator GPU rig grading service with open rules. Whoever holds access to a rig runs an open, pinned benchmark container on it. The grading endpoint grades the result against fixed, published bars for the rig's peer class (similar cards) and workload class (job type: inference or training), and returns a label and an evidence pack. Grades are labels of measured quality, not promises.

Status (1 Nov 2026): live at https://riggrade-674098696181.us-central1.run.app/riggrade/v1 with paid grading on. Agents can read /.well-known/agent.json, /llms.txt and /riggrade/v1/openapi.json on that host. Prices: 3 USDC per workload class for consumer cards, 5 USDC for data-centre cards, paid by x402 (USDC on Base). While a GPU class has no reference yet, each rig's first session there is free.

• Grading spec, v0.1
• Sample grading of three fictional rigs
• Preflight check: the kind of acceptance test big buyers run before paying for GPUs, for everyone else. Free one-minute check of a rented or hosted GPU box (throttling, foreign processes, driver vs CUDA, PCIe link, download and disk speed). python3 -m runner.preflight. Not a grade.
• GPU health monitor for hosts: riggrade-monitor runs the light checks every 6 hours, never while a renter's job holds the card, and alerts on your own webhook when a check gets worse or recovers. Free; nothing is sent to RigGrade.
• GPU index method, v0 draft: daily listed price per GPU-hour by peer class, and price per unit of measured work once graded rigs exist. Method published before any value. Recorder: python3 -m pricewatch.record --out PATH.
• Cluster acceptance test, spec v0 draft: checks a rented multi-node cluster against its provider's own claims (inventory, node health, stragglers, inter-node fabric, storage) and writes an evidence pack. The signed certificate is on sale at 25 USDC (see the offer below).
• MCP server for agents: riggrade-mcp (or python3 -m riggrade.mcp) exposes gpu_preflight, gpu_price_index, verify_certificate and riggrade_service_info over stdio. pip install riggrade.
• Products: the host fix-it report (2 USDC) and the cluster acceptance certificate (25 USDC), each on sale only when the service names it.
• Payments: x402 through keyless public facilitators with an automatic backup; payer screened against the OFAC list before settle. Payments are live; the descriptor at /riggrade/v1 lists what is on sale.
• Reconstructed price history method, v0 draft: a separate, labelled series from third-party records, never joined to the live index; no reconstructed grades.
• Cluster acceptance certificate: the offer in one page, with a sample certificate; a certificate's lookup URL renders as a printable page in a browser (?format=html), the dispute copy.
• Fleet rails readiness: what AgentCore, Cloudflare's gateway, MPP and the metered scheme need, and where RigGrade stands.
• Pooled preflight results method, v0 draft: opt in with --share; anonymised summaries only; class aggregates publish once reviewed and five results deep.
• Compute supply ledger method, v0 draft: six links from chips to rigs, two of them RigGrade's own measurements, with named reconciliation signals. Method published before any value; no value yet.
• Free GPU price index (live): GET /riggrade/v1/index and the MCP tool gpu_price_index give the latest listed on-demand price per peer class, weekly, reconstructed from GetDeploying's CC BY 4.0 dataset with attribution; the full series ships in the package as riggrade/index/reconstructed-getdeploying.{json,csv} and is re-imported every Tuesday. Information, not an offer.
• Smoke test from Google Drive: the same free GPU test, reading the code from Drive after checking it against a manifest (scripts/stage_for_drive.py) and writing both reports back to Drive.
• Smoke test notebook: checks the GPU code paths on a free Colab or Kaggle GPU. Not a grade: small model, short run, local endpoint with the sale off. Command: python3 -m runner.smoke --minutes 2.

Use the MCP server

Standard library only, stdio, no secrets. Four tools: gpu_preflight (free, runs on the box the server runs on), gpu_price_index, verify_certificate and riggrade_service_info.

Claude Desktop or Claude Code (claude mcp add riggrade -- riggrade-mcp), or in any MCP client config:

{"mcpServers": {"riggrade": {
  "command": "riggrade-mcp", "args": [],
  "env": {"RIGGRADE_ENDPOINT": "https://riggrade-674098696181.us-central1.run.app/riggrade/v1"}}}}

Install

pip install riggrade          # PyPI, no dependencies (torch, if present, runs the GPU load checks)
riggrade-preflight            # the free one-minute check, on the box you rented
riggrade-monitor --once       # the free host monitor (docs/monitor.md)
riggrade-mcp                  # the MCP server (stdio) for an agent
riggrade-verify cert.json     # verify a cluster acceptance certificate offline

The package carries the free price index data and the published spec; the benchmark container is separate and run by digest (below).

Running a graded session

The grading server is deployed from a separate private operations repository; the code it runs is this one at main.

The benchmark container is public: ghcr.io/nnyycc77-ship-it/riggrade-bench, pinned by digest in container/bench-image.env. The server accepts result bundles only from a listed digest, so run it by digest, never by tag:

. container/bench-image.env
# RIGGRADE_IMAGE_DIGESTS (plural) comes from bench-image.env; the container reads the singular name.
docker run --rm --gpus all -e RIGGRADE_IMAGE_DIGEST=$RIGGRADE_IMAGE_DIGESTS \
  -e RIGGRADE_ENDPOINT=https://riggrade-674098696181.us-central1.run.app/riggrade/v1 \
  $BENCH_IMAGE --help

The container carries the runner and the spec only. The grading server, payment code and screen list never ship in it.

Independence

Payment never buys the outcome: the method, the price and the verdict rules are the same whoever pays, the payer is printed, and failed results stay in the record. RigGrade takes no referral, affiliate, listing or sponsorship money from marketplaces, hosts or operators, including referral credits for marketplace templates. See docs/independence.md (draft under review).

Licence

Apache License 2.0; see LICENSE. The benchmark is open so that anyone can inspect and rerun the test behind a grade.

Rules for this repo

• Never commit secrets, keys, wallet private material or credentials.
• Never commit customer data: evidence packs, host identities or wallet-linked results.
• One branch and one pull request per meaningful piece of work. No automated loops that open or merge pull requests.
• GitHub Actions run tests only.