GPU Providers

Run a GPU on the SPACE OS network. SpaceRouter sends inference requests to your node, you serve them, and you get paid in stablecoin per request — 90% of the request revenue, with the protocol keeping 10%.

This page explains how the offering works end-to-end.

Status: Testnet. The full provider stack is rolling out in two phases. Phase 1 (live today) is SpaceStaking + SpaceSettlement on EVM chain 800000 — wallet-level staking and per-request payout. Phase 2 (coming) is SpaceProviderBond for per-device collateral, the device pairing flow, and slashing. The roadmap section at the bottom of this page is the honest read.

How it works

You                                           SPACE OS
 │                                                │
 ├─ Pair the GPU with your wallet                 │
 │     (6-digit code from the dashboard)          │
 │                                                │
 ├─ App-API verifies the endpoint:               ◄─┤  test inference + TLS + region
 │     - reachability + valid TLS                 │
 │     - 1-token completion                       │
 │     - signed nonce from device key             │
 │                                                │
 ├─ Bond the device on-chain                     ◄─┤  SpaceProviderBond.bond(deviceId, ...)
 │     (per-GPU collateral, slashable)            │
 │                                                │
 ├─ Stake SPACE for an earnings multiplier       ◄─┤  SpaceStaking.stake(amount)
 │     (optional — Free tier needs no stake)      │
 │                                                │
 ├─ Heartbeat every 60s                           │
 │                                                │
 ├─ Serve inference requests                     ◄─┤  routed by SpaceRouter
 │                                                │
 └─ Claim earnings any time                      ◄─┤  SpaceSettlement.claim(USD.s)

Two things are deliberately separate: the wallet stake (commitment signal that gives you a multiplier) and the per-device bond (collateral that backs each GPU and gets slashed for bad uptime). They live in different contracts and serve different purposes.

Tiers

Tiers apply to your wallet's SPACE stake. They multiply your inference earnings and weight your routing priority.

You can run a GPU at the Free tier with zero stake — the multiplier is a bonus, not a barrier to entry. Stake unbonds with a 7-day cooldown. See Staking for the staking mechanics.

Per-device bond

Each GPU you register requires a small bond posted to SpaceProviderBond. The bond is what gets slashed if the GPU misbehaves — your wallet's main stake is never at risk for device-level issues.

Bond is returned (minus any slashes) when you unregister the device, after a 7-day cooldown.

Hardware requirements

• NVIDIA GPU with 16 GB+ VRAM (CPU-only providers can serve smaller models — see the CPU install command below)
• Docker + NVIDIA Container Toolkit
• Public IP or stable outbound connection
• Target: <100 ms latency, 99.5% uptime

Install

GPU provider:

curl -fsSL https://spaceos.com/@gpu | sudo bash

CPU provider (smaller models, no GPU bond):

curl -fsSL https://spaceos.com/@cpu | sudo bash

Network node (chain validator, no inference):

curl -fsSL https://spaceos.com/@node | sudo bash

The installer auto-detects the GPU via nvidia-smi, prompts for the pairing code from your dashboard, runs endpoint verification, and starts the heartbeat loop.

Earnings

Inference revenue is paid in stablecoin (USD.s) on EVM chain 800000. SpaceRouter calls SpaceSettlement.settle(provider, USD.s, amount, requestId) afterll each request; 90% accrues to your wallet, 10% to the protocol treasury. You call claim() to withdraw whenever you like.

Indicative monthly earnings (Free tier, 80%+ uptime)

Multiply by your tier (Free 1.0× / Basic 1.25× / Pro 1.5× / Enterprise 2.0×). Actual earnings depend on network demand, the models you support, your latency, and your region.

Slashing

Bad uptime takes from the device bond, not from your wallet stake. The router stops sending traffic well before slashing kicks in — most underperforming providers just see their request rate drop, never a slash event.

Slashed funds go to the network insurance pool.

What you keep, what you risk

Roadmap (be honest about what's live)

• ✅ SpaceStaking.sol deployed — wallet staking, APY, tier multipliers readable on-chain.
• ✅ SpaceSettlement.sol deployed — per-request 90/10 payout in USD.s.
• 🚧 SpaceProviderBond.sol — per-device bond, slashing, liveness attestation. Specifying now.
• 🚧 Device pairing flow (/api/devices/pair-code, /api/devices/pair, heartbeat ingest). The legacy POST /api/network/register-gpu endpoint referenced in older docs is deprecated and was never implemented — use the pairing flow once it ships.
• 🚧 Endpoint verification (TLS probe, test inference, signed nonce) gated before bond clears.
• 🚧 SpaceRouter eligibility read from SpaceProviderBond instead of legacy chain-state.

Phase 1 providers earn today via wallet staking + settlement. Phase 2 adds the per-device bond layer on top — existing providers will be migrated by registering each device through the new pairing flow when it ships.

See also

• Staking — how SPACE staking works and the unbond cycle
• Network — public testnet endpoints
• AI Inference API — what your GPU actually serves