Connect a data centre's idle GPUs to Linkrra

If you own or host the hardware, an idle hour is not neutral — it costs you power and wear and returns nothing. Connected here, the same hour earns twice over: the card mines PRL whenever nothing is being asked of it, and serves AI inference when a request arrives. You keep 75% of what the card bills, paid in USDC on Base, and your PRL is paid to your own address. Nothing is exclusive: you can connect one machine, keep the rest where they are, and stop whenever you like.

1. 1

   Ask the pool what your cards can do

   One HTTP call per card model — not per machine. Nothing is installed and nothing is downloaded. Give it the VRAM the driver reports and the card's name; it answers with the model that card would serve and the exact settings it would run. This asks for every card in the box, because a plan is per card and a mixed machine gets a different answer on each:

   Copy

   nvidia-smi --query-gpu=index,name,memory.total --format=csv,noheader,nounits |
   while IFS=, read -r i name vram; do
     echo "== GPU$i $name"
     curl -s -G "https://pool.linkrra.com/v1/nodes/recommend" \
       --data-urlencode "vram_mib=$(echo $vram)" --data-urlencode "gpu_name=$(echo $name)"
   done

   The part that decides whether a card is worth connecting is reason:

   It says	What that means
   serve_and_mine	Serves inference and mines in the gaps. 32 GB cards (RTX 5090) and up.
   serve_only	Serves, but has no VRAM left for the miner once the model is resident. 24 GB cards (RTX 4090, 3090).
   servable: false	Too small or too old for the serving kernels. The card can still mine — see the NVIDIA rig guide.

   The bar is 24 GB of VRAM and compute capability 7.5 or newer. Below that a card cannot hold the model we serve at all. Run this across your card models first and you turn a fleet rollout into a list instead of a gamble.
2. 2

   Prepare one machine

   Pick a single machine to prove the path before you touch the fleet. It needs an NVIDIA driver, Python 3.10 or newer, and a build toolchain — the serving engine compiles a small GPU shim the first time a model loads, on your machine.

   Copy

   sudo apt update
   sudo apt install -y build-essential python3-dev python3-venv

   Do not skip the toolchain. Without the Python C headers the installer now stops in a couple of seconds and tells you what is missing. Before 2026-11-03 it stopped after downloading about 17 GB of model weights, which is the one failure we most wanted to spare you.
3. 3

   Install, serve, register — every card in the box

   Two addresses and a key. The PRL address is where mined PRL goes; the USDC address on Base is where inference earnings go, and you can leave it out now and bind it later. The API key is created at the dashboard. Run this once per machine, not once per card:

   Copy

   curl -fsSL https://pool.linkrra.com/install.sh -o install.sh
   less install.sh                     # we would rather you read it first
   sudo LINKRRA_PRL_ADDRESS=prl1...  \
        LINKRRA_USDC_ADDRESS=0x...   \
        LINKRRA_API_KEY=sk-pool-...  \
        LINKRRA_NODE_HOST=YOUR.PUBLIC.IP \
        bash install.sh

   It finds every card, asks the pool for a plan per card, and installs one model server, one node registration and one pinned miner for each. An 8-GPU server becomes eight nodes on ports 8000–8007, each registered separately, each with its own miner that stops only for its own card's requests. Cards too small to serve are listed and skipped; they can still mine.

   Every precondition — driver, Python, toolchain, disk for every distinct model, the pool's reachability, and whether each card's memory budget actually works — is checked before the download starts. A machine that cannot serve says so in seconds and has fetched nothing.

   Open one TCP port per card — 8000 to 8000+N−1 — to the internet, or to the pool's address only. The pool reaches in to each node and probes it before accepting it, so the URL has to be the one the outside world uses. On hosts that remap ports, pass the external URLs explicitly and in card order: LINKRRA_NODE_URLS="http://host:50018,http://host:50019". Behind NAT with no port open, a node is never given work.

   With sudo it installs systemd units and starts them, so the box comes back by itself after a reboot or an OOM. One card restarting never touches another:

   Copy

   systemctl status 'linkrra-serve@*'      # is every card up
   journalctl -fu linkrra-register@0       # registration + heartbeat, card 0
   systemctl restart linkrra-serve@3       # one card only
   systemctl stop linkrra-node.target      # the whole box

   Each card's registration prints its node id and status:

   Copy

   Registered: node_f889091f958ee374 — status: pending_approval

   pending_approval is the normal first answer, and it means the node is not yet earning from inference. Being in the registry and being handed a customer's prompt are different things: the requests we would route to you contain other people's data, so approval is a deliberate decision on our side. We check first — we reach each of your nodes with its own key, confirm it serves the model id it registered under, send a real completion, and read back the context your cards actually hold — and then a person approves. Your registration raises that review by itself; you do not have to chase it. Meanwhile your cards mine PRL and are paid for it. If you want to tell us who you are, or you have not heard within a business day: weare@linkrra.com.

   One model per card, never one model across cards. The plan the pool computes is sized to a single card, so we do not run tensor parallelism on this tier and would rather say so than guess at a configuration we have not measured. If your use case needs a model larger than one card holds, talk to us instead of forcing it.
4. 4

   Confirm it earns, then roll out

   Your statement is one call, any time, and shows only your own figures:

   Copy

   curl -H "Authorization: Bearer sk-pool-..." https://pool.linkrra.com/v1/earnings

   Once one machine is proven, the installer is fully non-interactive, so a rollout is a loop over the machines whose card models came back servable in step 1. One invocation per machine, whatever number of cards it has:

   Copy

   LINKRRA_YES=1 LINKRRA_PRL_ADDRESS=prl1... LINKRRA_API_KEY=sk-pool-... \
   LINKRRA_NODE_HOST=THIS.MACHINE.IP bash install.sh
   #   LINKRRA_GPUS=0,1,2   restrict to some cards; the rest stay yours
   #   LINKRRA_PORT=9000    move the port block

   Already mining another coin, or with another pool? Keep doing it. LINKRRA_IDLE_IMAGE and LINKRRA_IDLE_ARGS run any GPU miner on an idle card instead of ours; it is pinned to that card and never touches the serving path. If your pool partners with us, it earns a share of what your cards serve. Serving is an extra income stream on idle capacity, not a migration.

   Talk to us → — not required to get out of pending_approval (registering raises the review on its own), but it is the fastest way to put a name to the address. Send the card models, roughly how many, and the node ids if you have them. Ask before you install and we will tell you what is realistic.