Become a Provider · SeedInfer

Live model: Gemma 4 26B A4B NVFP4Zero-Account Ed25519 AuthHardware Fingerprint LockCUDA 13.3 · Driver 580+99% revenue share · monthly USDC on Base

Become a node operator

Serve google/gemma-4-26b-a4b-nvfp4 on an NVIDIA GPU with at least 32GB VRAM (reference node: RTX 5090 32GB). No account registration needed — the agent generates an Ed25519 key and a hardware-bound identity on first start. You receive 99% of the token revenue your node serves (1% protocol fee) plus a standby retainer of $0.40/day per node with ≥50% uptime that day. Payouts: USDC on Base, monthly, minimum $1.00.

Standby retainer

$0.40 / day per node

paid for each day the node has ≥50% uptime

Revenue share

99% of token revenue

1% protocol fee · min payout $1.00

Context & Hardware

256K · ≥32GB VRAM

NVFP4 weights + FP8 KV cache · 24GB cards not supported yet

One-liner install provider.tar.gz https://seedinfer.com/install.sh

Minimum Node Requirements

OSUbuntu 24.04+

Driver580+ (cu13.3)

GPUNVIDIA

VRAM32GB min

Docker24+ + nvidia-ctk

Disk60GB+ free

Ports: 47900 (vLLM) + 47901 (agent). The mesh VPN runs in its own container and does not interfere with an existing VPN on the host.

Other NVIDIA hardware? Apply for custom onboarding →

Provider Revenue & Net-Profit Calculator

Real-World Hardware Economics

Line-by-line estimate for hosting models on an NVIDIA RTX 5090 32GB reference node. Providers receive 99% of token revenue (1% protocol fee) plus a standby retainer of $0.40/day per node with ≥50% uptime that day. Throughput and power figures are adjustable assumptions, not guarantees.

99% revenue share

Estimates, not guarantees

Earnings depend on real network demand. The network is at an early stage, so actual traffic per node may be far below the baseline assumption (200M input / 20M output tokens per day at 30% load). Payouts: USDC on Base, monthly, minimum $1.00.

Select Hosted Model StrategySelect model architecture to calculate yield

Active Rig Profile & Rates

NVFP4 · 256K ctx

GPU Hardware

NVIDIA RTX 5090 32GB

21,760 CUDA cores · 1,792 GB/s · 575 W TDP

Selected Model Rates

$0.03 in / $0.20 out

Per 1,000,000 processed tokens

Average GPU Card Utilization30% Average Load

5% (Low)30% (baseline assumption)100% (Full Capacity)

Daily Input Tokens200M / day

Rate: $0.03 / 1M input tokens

Daily Output Tokens20M / day

Rate: $0.20 / 1M output tokens

Electricity Tariff & Power Consumption$0.25 / kWh

$0.05 (Solar/US Low)$0.25 (EU Avg)$0.50 (High Tariff)

Avg Power Draw: 220 W average (TDP 575 W)

Monthly Energy: 158.4 kWh

Monthly Profit Summary

$269/mo net

Estimated net / month (Gemma 4 26B)

$269/ mo

After electricity, on 1× RTX 5090 32GB

Monthly Statement (30 Days)Gemma 4 26B

Token revenue (gross)$300.00

200M in × $0.03 + 20M out × $0.20 per day × 30

Your share (99%)+$297.00

1% protocol fee: -$3.00

Standby Retainer+$12.00

$0.40/day per node with ≥50% uptime that day (assumes every day qualifies)

Electricity Cost-$39.60

220 W avg (~158 kWh) @ $0.25/kWh

Net Monthly Profit$269.40

Formula: net = token revenue × 0.99 + $0.40 × 30 days − kWh × tariff. Payouts: USDC on Base, monthly, minimum $1.00.

Become a provider

NVIDIA GPU with ≥32GB VRAM · Ubuntu 24.04 LTS · vLLM + Docker · 24GB cards not supported yet

Platform Comparison: Vast.ai vs SeedInfer Freedom

Why P2P Inference Beats Traditional Rental Platforms

Full GPU Ownership & Flexibility

Traditional platforms like Vast.ai lock down your host system, demand 24/7 continuous availability, and grant tenant root/kernel access. SeedInfer runs as an isolated user-space container—giving you complete freedom to pause or use your GPU anytime without penalty.

Feature / Parameter	Vast.ai (Traditional Rental)	SeedInfer P2P Network
How you earn	Hourly rental while a tenant occupies the machine	99% of token revenue + $0.40/day per node with ≥50% uptime that day
GPU Owner Freedom & Flexibility	0% Freedom (Requires 24/7 non-stop availability or rating drops)	100% Freedom (Pause, game, render, or work anytime)
Host System & Privacy Security	Kernel / Root Access (Strangers get SSH access to host system)	Zero Kernel Access (Isolated Docker + Tailscale user-space)
Network Bandwidth Requirements	Min 1 Gbps Symmetric Fiber mandatory	Standard Consumer Broadband (Smart Prefix Caching)
Power Consumption & Heat Strain	Continuous full load while rented (up to 575 W TDP)	~220 W average at 30% load (~$40/mo @ $0.25/kWh)

Custom hardware application

[email protected]

Running NVIDIA hardware other than the reference RTX 5090 32GB? Any NVIDIA GPU with at least 32GB VRAM (e.g. RTX 6000 Ada, L40S, A100, H100, multi-GPU servers) can apply for custom onboarding. 24GB cards (RTX 4090 / 3090) are not supported yet — you can still register your interest below.

Create a node token in the Provider portal (sign-in required)Then run the installer below with your token.

Open portal

Technical Setup & Node Onboarding Guide

Zero-Account Architecture: Key Pair & Hardware Lock
Ed25519 + SHA-256 Hardware Fingerprint

How SeedInfer identifies your node without an account, email or password:

1. Private key

Local file: /opt/seedinfer-provider/seedinfer.key

Generated automatically (Ed25519) on the first container start. It never leaves your machine and is never sent over the network. It signs heartbeats and served-token reports.

Perms: 600 (-rw-------) · Never share seedinfer.key

2. Public key

Identifier: pubkey_ed25519_...

Public node identifier reported to the SeedInfer gateway (/api/v1/providers). It acts as your anonymous settlement identity: use it to check node status and TTFT in the dashboard. Payouts go to your USDC address on Base.

Registration: automatic on the first heartbeat

3. Hardware fingerprint

Signature: SHA-256(GPU_UUID + PCIe_Bus + machine-id)

A hardware signature computed by the agent from the physical GPU (nvidia-smi) and the machine id. It binds your key to the physical machine so the node identity cannot be cloned. A mismatch pauses traffic immediately (HARDWARE MISMATCH).

Protection: detects cloned VMs / copied private keys

One-line installation (Linux)curl | bash

One command on Linux (Ubuntu 24.04+): create a node token in the Provider portal (sign-in required), then run the command with your token — it checks the GPU with nvidia-smi and ports 47900/47901, installs Docker + NVIDIA Container Toolkit + the mesh VPN container and starts the inference engine.

Node token

Create a node token in the Provider portal (sign-in required) and pass it as SEEDINFER_NODE_TOKEN=sipn_… or --token sipn_….

Recommended — one command (with your node token)

curl -fsSL https://seedinfer.com/install.sh | SEEDINFER_NODE_TOKEN=sipn_YOUR_TOKEN bash

Create a node token in the Provider portal (sign-in required) and pass it to install.sh. The installer pulls the prebuilt image ghcr.io/seedinfer/provider:cuda13.3-nvfp4 (falls back to a local build).

Gateway https://seedinfer.comPrebuilt image → docker compose

Advanced — custom key / model / gateway / envExpand

1 · With your node token (--token)

curl -fsSL https://seedinfer.com/install.sh | bash -s -- --token sipn_YOUR_TOKEN

2 · All parameters

curl -fsSL https://seedinfer.com/install.sh | bash -s -- --token sipn_YOUR_TOKEN --model google/gemma-4-26b-a4b-nvfp4 --gateway https://seedinfer.com --hostname my-gpu-node

Environment overrides: SEEDINFER_PREBUILD_IMAGE=ghcr.io/... · VLLM_PORT=47900 · AGENT_PORT=47901

Installation steps — from curl to a live node~5 min + model download

1
curl install.sh
Checks the GPU (nvidia-smi, min 32GB VRAM), driver 580+ (CUDA 13.3) and free ports 47900/47901, then installs Docker, nvidia-container-toolkit and the mesh VPN.
```
nvidia-smi VRAM OK (≥32GB) driver 580+ · CUDA 13.3 OK
```
2
Isolated mesh VPN
Containerized — the installer runs the SeedInfer mesh in its own container (tailscale-seedinfer). Your existing VPN stays connected.
```
Host VPN: unchanged Container: SeedInfer mesh
```
3
Docker Pull / Start Engine
Pulls ghcr.io/seedinfer/provider:cuda13.3-nvfp4 and downloads the Gemma 4 26B A4B NVFP4 weights into the local model cache.
```
docker compose up -d --build model weights → local cache
```
4
Health check & Fleet Join
The agent sends a signed Ed25519 heartbeat every 30s. After 2 valid heartbeats the gateway verifies the node and moves it from verifying to verified. Nodes silent for 5 minutes are shown as offline.
```
Status: pending → verifying → VERIFIED Routing active
```

Install package & console commands

provider.tar.gz

Full provider/ package — Dockerfile.cuda + compose + agent

Download tar.gz →

install.sh

One-line install script

https://seedinfer.com/install.sh

Provider docs

Mesh networking and environment variables

Open /docs →

Local check (on your machine)

# 1. Container status:
docker ps | grep seedinfer-provider

# 2. Agent health (port 47901):
curl -fsS http://127.0.0.1:47901/health | jq

# 3. vLLM model list (port 47900):
curl -fsS http://127.0.0.1:47900/v1/models | jq

Gateway check (remote)

# Is your node visible?
curl -fsS https://seedinfer.com/api/v1/providers | jq '.data[] | {id,status,verification}'

# Active nodes:
curl -fsS https://seedinfer.com/api/stats | jq '.active_providers'

Supported models & GPUs (CUDA 13.3)
Reference: RTX 5090 32GB

Reference node: NVIDIA RTX 5090 32GB (21,760 CUDA cores, 1,792 GB/s, 575 W TDP). Driver 580+ and CUDA 13.3 are required for NVFP4 models. Minimum 32GB VRAM.

Model ID	Hugging Face repo	Price in / out (1M)	Context	Status
google/gemma-4-26b-a4b-nvfp4	nvidia/Gemma-4-26B-A4B-NVFP4	$0.03 / $0.20	256K	live
seedinfer/nemotron-lightning-1m	nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4	$0.02 / $0.05	1M	coming soon
qwen/qwen3.6-35b-a3b	—	$0.06 / $0.50	256K	coming soon

GPU	VRAM	TDP	Status
RTX 5090 32GB	32GB	575 W	Reference node
RTX 6000 Ada 48GB	48GB	300 W	Supported
2× L40S 48GB	96GB	700 W	Supported
A100 80GB	80GB	400 W	Supported
H100 80GB	80GB	700 W	Supported
24GB cards (RTX 4090 / 3090)	24GB	450 W	Not supported yet — on the roadmap

SeedInfer.com · Provider portal · Phase 0

/install.sh·/provider.tar.gz·/provider/portal·/api/v1/providers·/docs