>Tutorial: Operator End to End

Every step in order, each paired with the exact command or Console action and the result you should see. CLI steps run on the machine; Console steps run at app.parallelix.io. Commands copy without the leading prompt; nodeId, stake, and rewards are your own.

1. // 01Install the stack

   node cli

   On the machine that will run the node, run the one-line installer. On a fresh Linux GPU box it installs Node, the Ollama inference runtime, the default model, and the parallelix-node CLI. macOS works the same way; on Windows, run it inside WSL2.

   parallelix.nodehost·gpu-box · installer

   $curl -fsSL https://parallelix.io/install.sh | sh

   ✓node 22.x→runtime

   ✓ollama→inference runtime

   ✓llama3.2→default model · 4.7 GB

   ✓parallelix-node→v1.2.1

   ·next · run: parallelix-node probe

   OSLINUX▪RUNTIMEOLLAMA▪CLI1.2.1// sample

   step 01COPY

   $ curl -fsSL https://parallelix.io/install.sh | sh

   →Node, Ollama, llama3.2, and parallelix-node installed and ready.

2. // 02Probe the hardware

   node cli

   Detect the GPU and VRAM, confirm Ollama is running, and print the tier the machine maps to. CPU is tier 1; GPU is tier 2/3/4 by VRAM. Note the tier; you declare it on-chain in step 6.

   parallelix.nodehost·gpu-box · probe

   $parallelix-node probe

   ·cpu 16 cores

   ·memory 64 GB

   ·gpu NVIDIA RTX 4090 · 24 GB VRAM

   ›ollama running (v0.x)

   ✓maps to tier 3→GPU · high

   GPURTX 4090▪VRAM24 GB▪TIER3// sample

   step 02COPY

   $ parallelix-node probe

   →Prints the detected GPU and 'maps to tier N'. Note the tier.

3. // 03Pull a model

   node cli

   Confirm a model is installed, or pull one. The installer already pulled llama3.2; this is how you add or check others. At least one model must be present before start.

   parallelix.nodehost·gpu-box · models

   $parallelix-node models pull llama3.2

   ·pulling llama3.2 into ollama

   ✓manifest→resolved

   ✓layers→4.7 GB

   ✓llama3.2 ready→open-source model

   MODELLLAMA3.2▪SIZE4.7 GB▪RUNTIMEOLLAMA// sample

   step 03COPY

   $ parallelix-node models pull llama3.2

   →The model is listed under `parallelix-node models`.

4. // 04Initialise the node key

   node cli

   Generate the separate, low-value secp256k1 node key (never your staking wallet) and print the nodeKeyHash. This key signs liveness and results only. Copy the nodeKeyHash; you paste it into the register form.

   parallelix.nodehost·gpu-box · init

   $parallelix-node init

   ✓node key generated→~/.parallelix/node.key · 0600

   ✓config written→~/.parallelix/config.json

   ·register on-chain (Console), using:

   ·tier 3 (GPU · high)

   ✓nodeKeyHash→0x9c27a4f1...e83b

   KEYSECP256K1▪PERMS0600▪TIER3// sample

   step 04COPY

   $ parallelix-node init

   →Prints the tier and the nodeKeyHash to register on-chain. Copy the nodeKeyHash.

5. // 05Connect your wallet

   console

   Open app.parallelix.io and connect the wallet holding your $PRLX with MetaMask (it forces the account picker). The Console is the on-chain half; it never touches the node key.

   // operator · dashboardYour nodes

   3 active

   nodestateuptimeweight

   #4217active99.2%GPU · 2.5x

   #4218active98.0%GPU · 3.0x

   #4220active94.7%CPU · 1.0x

   #4231idle0%—

   nodes online3 / 4

   avg uptime97.3%

   stake posted410k $PRLX

   accrued reward23,515 $PRLX

   Rewards accrue from the 25% Operator Rewards bucket, weighted stake x tier x uptime. Idle nodes (no compute online) earn nothing.

   →The connected address shows in the Console header on Ethereum mainnet.

6. // 06Approve and register

   console

   In Staking, choose the tier from step 2 and a stake of at least 50,000 $PRLX, paste the nodeKeyHash, then approve $PRLX and sign registerNode(stakeAmount, tier, nodeKeyHash) on NodeRegistryLocker. One stake = one node = one permanent nodeId.

   contract callCOPY

   registerNode(stakeAmount, tier, nodeKeyHash)

   // operator · stake & registerone stake = one node

   1. 01

      Hardware tier

      Declare CPU or GPU tier. The CLI verifies it.

   2. 02

      Stake amount

      Lock >= 50,000 $PRLX. Higher stake, higher weight.

   3. 03

      Sign registerNode

      registerNode(stake, tier, nodeKeyHash) -> nodeId

   node #4231 registered · principal returned in full on unstake (7-day cooldown, no slashing)

   →The transaction confirms and the Console assigns your nodeId.

7. // 07Start the node

   node cli

   Attach this machine to the on-chain node. The daemon heartbeats and serves dispatched inference requests through Ollama. Use --gpu or --cpu to force the mode. Replace <id> with the nodeId from step 6.

   parallelix.nodehost·gpu-box · node #4217

   served inference · req/s▲ peak

   $parallelix-node start --node-id 4217 --gpu

   ✓node online→nodeId #4217

   ✓heartbeat→liveness · 10s

   ›request inbound · ai-inference · accepted

   ›serving inference · llama3.2 (open-source)

   ✓proof-of-execution→sha256 commitment

   ✓uptime 99.4%→rewards streaming

   STATEACTIVE▪POESHA-256▪REWARDSSTREAMING// sample

   step 07COPY

   $ parallelix-node start --node-id 4217 --gpu

   parallelix ai // open-source model · running8 live

   >requests routed to capable nodesoss-models

   node-11

   99%rtx-4090

   node-13

   91%rtx-4090

   node-15

   88%a6000

   node-04

   87%rtx-4090

   node-08

   78%a6000

   node-07

   72%a6000

   node-02

   61%rtx-4090

   node-09

   ··rtx-3090

   answers streaming→credits · metered off-chain

   1980 TFLOPS · fp168 streaming

   Each whole inference request streams on its own node across the pool. Your node serves requests it is matched to and accrues uptime while it does.

   →Shows 'active · heartbeats N · served N'. The node is online and accruing.

8. // 08Install as a service

   node cli

   To run 24/7, install the node as a systemd (Linux) or launchd (macOS) service that survives reboot and auto-restarts. This replaces the foreground start. On Windows, run it inside WSL2 where the Linux path applies.

   parallelix.nodehost·gpu-box · systemd

   $parallelix-node service --node-id 4217 --gpu

   ✓installed + started→service 'parallelix-node'

   ·logs: journalctl -u parallelix-node -f

   ·stop: sudo systemctl stop parallelix-node

   ✓survives reboot→auto-restart on crash

   MANAGERSYSTEMD▪BOOTENABLED▪RESTARTON-FAIL// sample

   step 08COPY

   $ parallelix-node service --node-id 4217 --gpu

   →Installed and started as a managed background service.

9. // 09Watch earnings stream

   console

   On the Earnings page, the claimable total ticks up per-second while the node is online. Reward weight is stake x tier; earned(nodeId) grows every block from the per-second stream.

   ParalleliX AI · inference requests

   1. 01

      Stake

      $PRLX on NodeRegistryLocker

   2. 02

      Run

      uptime heartbeats

   3. 03

      Serve

      one whole AI request

   4. 04

      Prove

      SHA-256 commitment

   5. 05

      Earn

      per-second stream

   Rewards stream from the 25% Operator Rewards bucket, unlocked linearly via Sablier (~34,200 $PRLX/day), streamed per-second to online nodes by stake x tier. No slashing: principal returns in full on unstake.

   // operator · earningsaccrues every block

   claimable

   23,515.31$PRLX

   // daily share
   weight = stake x tier x uptime
   share = daily_pool x weight / Σ weight
   source: 25% Operator Rewards bucket · ~34,200 $PRLX/day via Sablier

   claim(nodeId)wallet signs · paid to owner

   →A live per-second ticker showing accrued $PRLX per node.

10. // 10Claim

    console

    Pull the accrued balance to your wallet at any time, to wei precision. claimMany batches a claim across every node with a balance. Claiming does not interrupt accrual.

    contract callCOPY

    claim(nodeId)

    cap 25.0M $PRLXlinear ~1.04M / movia Sablier~34,200 / day

    Streamed per-second to online nodes by stake x tier. In steady state, an 85% share of ParalleliX AI usage payments funds rewards. The live released figure is on-chain via Sablier.

    →The accrued $PRLX transfers to your wallet; the ticker resets and keeps climbing.

11. // 11Pause and resume

    console · optional

    On the Nodes page, Pause is an owner-signed force-idle: it takes a node offline without unstaking (it moves to Idle and stops accruing). Resume brings it back online.

    →The node shows Paused / Idle, then Active again on resume.

12. // 12Request unstake

    console · optional

    When you want your principal back, call requestUnstake(nodeId). The node stops earning and a 7-day cooldown begins. cancelUnstake(nodeId) aborts it and returns the node to service.

    contract callCOPY

    requestUnstake(nodeId)

    →The node moves to Cooling with a countdown; the daemon self-stops on the 403.

13. // 13Wait out the cooldown

    console · optional

    The 7-day cooldown timer runs on the node card. There is no slashing: the principal is safe the whole time.

    →After 7 days the node exposes Withdraw stake.

14. // 14Withdraw

    console · optional

    Call withdrawStake(nodeId). The full principal returns to your wallet and the nodeId is permanently retired. To rejoin, register a new node.

    contract callCOPY

    withdrawStake(nodeId)

    →Full stake returned; the nodeId is retired and not reusable.