NODES ONLINE7//POE · SHA-256 COMMITMENTREGISTERED9//COORDINATION · ETHEREUM L1STAKED551,000 $PRLX//NO SLASHING · PRINCIPAL RETURNED IN FULLREWARD POOL1.70M $PRLX//PARALLEL-NATIVE · REQUEST ROUTINGSTREAMING17.3 $PRLX/S//$PRLX · 100M FIXED · 0% INFLATIONREWARDSPER-SECOND · UPTIME-WEIGHTED//PARALLELIX AI · OPEN-SOURCE INFERENCENODES ONLINE7//POE · SHA-256 COMMITMENTREGISTERED9//COORDINATION · ETHEREUM L1STAKED551,000 $PRLX//NO SLASHING · PRINCIPAL RETURNED IN FULLREWARD POOL1.70M $PRLX//PARALLEL-NATIVE · REQUEST ROUTINGSTREAMING17.3 $PRLX/S//$PRLX · 100M FIXED · 0% INFLATIONREWARDSPER-SECOND · UPTIME-WEIGHTED//PARALLELIX AI · OPEN-SOURCE INFERENCE
network
ParalleliX.
Decentralized Parallel Computing Network

Run EverythingIn Parallel

Stake $PRLX, run a node, and earn streaming rewards for uptime. Your GPU or CPU joins the pool and serves inference requests the scheduler routes to it. Throughput scales with the nodes online.

Run a NodeRead the docs
parallelix.console9c27a48f
node.live
dispatch.in
rewards
MESHokCHAINokPOEok
$parallelix-node start --gpu --tier 2
✓node onlinenodeId #1042
✓heartbeatliveness · 12s
›request inbound · ai-inference · accepted
›serving inference
✓proof-of-executionsha256 commitment
✓uptime 99.4%+162 PRLX · rewards streaming
MESHGLOBALREQS142POESHA-256L1ETHEREUMFRAME 04v0.1.0// SAMPLE

// demand: ParalleliX AI

  1. 01
  2. 02
  3. 03
  4. 04
  5. 05

ParalleliX AI creates the demand. Operators stake, run nodes, and earn streaming rewards for uptime.

Plug In

Plug Into The Parallel Stack.

Three ways in. Operators stake $PRLX and run a node for uptime rewards. ParalleliX AI users spend $PRLX credits on inference. Holders carry the work currency.

  • // operators

    Run A Node.

    Stake $PRLX to register a node, install the Node CLI on your GPU or CPU, keep it online. Rewards stream per-second to online nodes for uptime, claimable any time. No slashing: your stake is always returned.

    Operator brief
  • // ai users

    Use ParalleliX AI.

    Open-source models running on network compute. Deposit $PRLX into an on-chain credits vault, spend per request, withdraw what you do not use. Every reply carries a verified Proof-of-Execution.

    Open ParalleliX AI
  • // holders

    Hold The Utility Token.

    $PRLX is the work currency of the network. ERC-20 on Ethereum. 100M fixed. No inflation. Holding does not stake and does not earn.

    Token details
Skip walkthrough
How It Works

Requests In. Scheduled Across The Pool.

Requests in. Scheduled across the node pool. Throughput scales with the network.

// 01

Receive

receive(req) → queue[REQ-4821]
PARSEENQUEUECLASSIFY

ParalleliX AI streams inference requests to the coordinator. Each request carries a model name, token count, and hardware class. The coordinator queues them for scheduling.

// 02

Dispatch

dispatch(REQ-4821) → node-09[EU-W]
MATCHROUTEFAN-OUT

The scheduler routes each request to a capable, online node using four signals: capability match, capacity-aware queuing, best-fit allocation, and reputation weighting. Multiple requests fan out across the pool in parallel.

// 03

Serve

result(REQ-4821) → sha256:9a3b…
INFERSIGNRETURN

Each node runs the inference request and returns the result with a SHA-256 Proof-of-Execution hash commitment over (request_id, result, node_id). Add nodes and throughput rises.

Step 1 of 3: Receive
Run A Node

Two Halves, One Operator.

Your staking wallet holds the stake on the Console. A separate node key, made by the CLI, signs the machine liveness. Both keys, both halves, must run to earn.

CLI steps run on your machine. The Console step is on-chain.

  1. // 01CLI · off-chain

    Install

    curl -fsSL parallelix.io/install.sh | sh

    One binary, CPU or GPU mode.

    binary ready
  2. // 02CLI · off-chain

    Generate Node Key

    parallelix-node init

    Prints your nodeKeyHash, a separate low-value keypair. Your staking wallet private key never touches the machine.

    node key created
  3. // 03Console · on-chain

    Stake and Register

    registerNode(stake, tier, nodeKeyHash)

    On the Console, your staking wallet stakes 50,000 $PRLX or more and binds the node to the nodeKeyHash from step 02. No slashing, principal returned on unstake.

    Open Console (opens in a new tab)
  4. // 04CLI · off-chain

    Connect and Go Online

    parallelix-node start --node-id <id> --gpu

    Heartbeats keep the node live. Uptime earns rewards that stream per-second while online.

    online, heartbeating

Your staking wallet runs the on-chain half on the Console: stake, register, claim. The node key runs the off-chain half through the CLI: liveness heartbeats, inference execution, Proof-of-Execution commits. Both must run for the node to accrue uptime and earn a pool share.

Inside A Node Session

A Node In The Mesh. Paid For Uptime.

Operators run real hardware. Declare what it can do. Stake $PRLX to register a node, then keep it online for rewards that stream per-second to online nodes. No slashing: the stake comes back in full.

Network Foundations

What A Node Runs On.

A node is a machine you stake to register and keep online. The coordination layer routes inference requests to it based on what your hardware can run, and pays you for uptime. ParalleliX AI is where most of that work comes from.

// 01Node

Permissionless, hardware-tiered nodes.

Anyone stakes $PRLX to register a node via NodeRegistryLocker, no allowlist. You declare a hardware tier and the workload classes your machine handles (AI, scientific, big-data, blockchain, rendering); the scheduler only routes work your hardware can run.

declared x verified
class filter
AI · GPUSCIENTIFICRENDERINGBLOCKCHAINBIG DATA
workload
5 signals
CUDA · FP32 · TENS · VRAM · LAT
nodehardware · classcapsregscore
node-04
RTX 4090 · 24 GB
AI · GPU
US-E5/5
node-09
HPC · 256 GB
SCIENTIFIC
EU-W2/5
node-15
RTX 4080 · 16 GB
RENDERING
AP-N3/5
node-22
EPYC · 64-core
BLOCKCHAIN
US-E1/5
filter: AI · GPU→ node-04
// 02Work

Inference requests are the unit of work.

ParalleliX AI sends a stream of inference requests to the coordinator. The scheduler routes each request to a capable, online node so the pool serves many at once. Your node runs whole requests, not fragments of one. Add nodes and throughput rises.

fan-out n-way
your request
R3 · node-15
model
open-llm-70b
running
6 nodes
reqnodetimeline · wall-clockelapsed
R1node-04
0.82s
R2node-09
0.91s
R3node-15
78%
R4node-22
62%
R5node-31
55%
R6node-07
41%
0s250ms500ms750ms1.0s
concurrent
6 req
your node
1 req
vs one node
6×
your node · 1 whole requestyour request 78%
// 03Routing

Capability-aware routing.

Requests match to nodes on four signals: capability match, capacity-aware queuing, best-fit allocation, reputation weighting. Better-matched, higher-uptime nodes draw more requests and a larger uptime-weighted pool share.

best-fit match
candidate pool
1,420nodes
evaluated in
14ms
01capability1,420 → 312−1,108
02capacity312 → 88−224
03best-fit88 → 17−71
04reputation17 → 1✓ 1
routed
node-04
RTX 4090 · US-EAST
reputation
97.4
of 100
4 signals✓ dispatched
// 04Security

Encrypted, authenticated dispatch.

Every request is encrypted to the assigned node's public key, so only that node can read it. Nodes sign with a low-value node key, never the staking wallet. The chain holds your stake; the node key does the talking.

per-node session key
handshake4 frames · 1.4ms
T+0.0→KEY_REQUEST384 B
T+0.3←PUB_KEY_EXCHANGE288 B
T+0.7→SESSION_AGREE128 B
T+1.4⇄CHANNEL_OPENAEAD
●x25519 outer
●ChaCha20 mid
●SEALED core
derived keysHKDF · 3 outputs
session_keyactive
ed25:7f3a · 91c8 · 4b22
mac_keyvalid
bc8d · 12e4 · 99af · 62
nonce_counterfresh
0000…c8d1f2a4
ChaCha20 active✓ sealed · authenticated
// 05Verification

Proof-of-Execution on every result.

Each result returns with a SHA-256 hash commitment over (task_id, result, node_id). The coordination layer reconstructs the hash to validate before the work counts. A hash commitment, not a zero-knowledge proof.

SHA-256 commit
inputs3 fields · hashed in canonical order
task_id
0x9c4d…f2a1
result
0xb3e7…a8f0
node_id
nx-0049
↓ sha-256 · 256-bit · deterministic
commitment verified
0x
4a91c91d
b8e6 · 5a12 · f3d7 · 8ea2
a3c1 · 047b · 9d2e · 6f70
algorithm
SHA-256
output
256 bit
ledger
anchored
network ledger✓ committed
ParalleliX AI

A Text-Only Chat App, Powered by Network Nodes

A text-only chat app, like ChatGPT, with its inference served by the network's own operator nodes instead of a central GPU farm.

// how it works
Models

Open-source models only. No proprietary weights.

Verified

Every answer is served by a real GPU node and carries a verified Proof-of-Execution.

Credits

Deposit $PRLX into an on-chain credits vault. Spend per message, metered off-chain, no per-message gas. Withdraw unspent credits any time.

Custody

Funds live in an immutable on-chain vault, withdrawable any time. The off-chain meter debits usage, and the operator share settles on-chain per served request.

Open ParalleliX AITelegram bot
What the network runs
AI Inferenceactive

chat, embeddings, classification

Scientific

parameter sweeps, genomics

Big Data

map-reduce, risk, logistics

Blockchain

proof generation, oracles

Media & Render

frames, encoding, AR/VR

Parallel Token

Stake. Run. Spend.

The work currency of the network. Operators stake it to run nodes, ParalleliX AI users spend it as credits. 100M fixed. No inflation. No holder yield.

// SUPPLY

100,000,000

$PRLX · ERC-20 · Ethereum

NameParalleliX Network
Decimals18
StandardERC-20
/View full tokenomics

// ON-CHAIN

CONTRACT

Live · Etherscan verified
0x93ff39f65cc1d21067939961993adf3f36bbf893
ETHERSCAN DEXSCREENER BUY

ERC-20·Ethereum Mainnet·No mint fn·5% buy/sell tax

// operate

Node Staking & Uptime Rewards

The Console and the Node CLI make one operator product. Stake $PRLX to register a node, run it on your GPU or CPU, and earn uptime-weighted rewards that stream per-second to online nodes. Permissionless. No slashing: principal is always returned. Pay for uptime, not yield.

minimum
50,000 $PRLX / node
cooldown
7-day unstake
slashing
none, ever
weight
stake × tier × uptime
rewards
25% rewards bucket
claim
on-chain, anytime
// credits

ParalleliX AI Credits

ParalleliX AI is a text-only chat app, like ChatGPT, with its inference powered by the network's own nodes. Spend $PRLX as credits: deposit once on-chain, meter off-chain, no per-message gas. As usage grows, a share of those payments funds operator rewards, closing the loop.

models
open-source
metering
off-chain meter
deposit
on-chain vault
usage
settles to operators

// DISTRIBUTION

LiquidityUNCX · 1 year60%·60,000,000

Deep liquidity for trading and price stability

Operator RewardsSablier · 24 mo linear25%·25,000,000

Bootstrap subsidy paid to operators for node uptime (streamed per-second, weighted by stake, tier, and uptime)

TeamSablier · cliff 12 + vest 2410%·10,000,000

12-month cliff + 24 months linear vest

TreasurySablier · streamed5%·5,000,000

Operational reserves and partnerships

Locker proofUNCX · view lockers

// TAX DISTRIBUTION

5%

buy/sell tax

split 3 ways

tax3-way
DEV2%

platform upgrades

OPS2%

infrastructure

MKT1%

awareness, partners

where it flows9 line items · on-chain transparent
  • DEVprotocol security · scheduler upgrades · SDKs
  • OPScoordinator nodes · monitoring · operator support
  • MKTbuilder outreach · partnerships · awareness

Tax does not fund operators · bootstrap covers that.

The Product Surface

Deploy. Read. Operate.

Three places to interact with the network: Console for operators, Docs for builders, Node Client for compute providers.

Built For The Operator.

Stake. Run. Earn for uptime.

Read tokenomics for the $PRLX spec. Read the docs for the protocol, the scheduler, the operator path.

Run a Nodeapp.parallelix.ioRead tokenomics$PRLX referenceRead the docsdocs.parallelix.io