Skip to main content
ParalleliX Docs

// Chapter 02 · Concepts

Network Anatomy

Four actors interact in every operation.

6 min4 sectionsConcepts

The shape of the network

// 2.0 · four actors, one orchestrator

Four actors take part in every operation. Demand pays in (ParalleliX AI at launch), operators execute, the coordinator orchestrates, and the on-chain anchor records.

// Network topologyat launch
  • // 01

    Demand side

    ParalleliX AI · pays in $PRLX

  • // 03

    Node operators

    execute · earn

  • // 02

    Coordinator

    schedules · dispatches · validates

  • // 04

    On-chain anchor

    ethereum · execution records

// Directional flows · four

  • 0102
    request envelope
  • 0203
    dispatch · whole to one node
  • 0302
    result + PoE
  • 0204
    anchor · ExecutionRecord

The four actors

// 2.1 · roles · at launch

// Actor ledger · 4 entries · at launch

  • // 01

    Demand side

    The live demand source is ParalleliX AI: users fund $PRLX credits, and each inference request becomes a unit of work on the network. A permissionless third-party submitter marketplace is a future direction.

    // MUST
    Deposit $PRLX to fund the credit balance
    // MAY
    Query request status; retrieve results
    // CANNOT
    See which node executed any request
  • // 02

    Coordination layer

    Schedules and dispatches each request whole to a capable node, validates results, and settles. On the general path it can segment genuinely parallelizable workloads into sub-tasks. At launch it is centralised, run by the ParalleliX team.

    // MUST
    Verify PoE commitments before settling
    // MAY
    Re-dispatch a sampled fraction to detect divergent results
    // CANNOT
    Decrypt request payloads in transit
  • // 03

    Node operators

    Independent participants running the node client on their own GPU/CPU hardware. Register capabilities, accept dispatched work, return signed results, earn uptime rewards.

    // MUST
    Stake at least 50,000 $PRLX per node on NodeRegistryLocker
    // MAY
    Decline work outside declared capability
    // CANNOT
    Forge a Proof-of-Execution for work they did not run
  • // 04

    On-chain anchor

    The blockchain layer where Proof-of-Execution records and stake, registration, uptime, and reward-accrual events are committed.

    // MUST
    Accept ExecutionRecord commits from the validator
    // MAY
    Be a public Ethereum block or an L2 rollup state root
    // CANNOT
    Be mutated without breaking the previous_hash chain

Caveat·The launch coordinator

At launch the coordinator is a single point of failure, run by the ParalleliX team. Public commitments anchor on-chain so that tampering is detectable after the fact, not prevented in the moment.

Inside the coordinator

// 2.2 · four logical services

The coordinator exposes four logical services. They may run in one process or across many. The architecture commits to behaviour, not topology.

// Coordination layer · pipelineat launch

  • // svc 01step 1/4

    Intake API

    Accepts requests, verifies $PRLX payment, enqueues for routing.

  • // svc 02step 2/4

    Segmenter

    For genuinely parallelizable workloads, splits the task graph into independent sub-tasks. AI inference is dispatched whole, not segmented.

  • // svc 03step 3/4

    Scheduler

    Matches each unit of work to a node using the four scheduling signals.

  • // svc 04step 4/4

    Validator

    Reconstructs PoE commitments, samples re-dispatch, settles payment.

How a node joins

// 2.3 · operator onboarding

A one-time bootstrap sequence the node client runs the first time it points at a coordinator endpoint. After this, the node settles into a long-lived loop: receive, decrypt, execute, commit, return, once per dispatched unit of work.

  1. // Bootstrap sequence · 5 steps
  2. 01

    Install the client

    Run the one-line install script. On Linux it installs Node, the Ollama runtime, the default model, and parallelix-node. macOS is supported the same way; on Windows, run it inside WSL2.

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

    Generate the node key

    parallelix-node init generates a separate, low-value node key pair under ~/.parallelix/keys/ with mode 0600 (the CLI refuses to run if permissions loosen) and writes the config. This key signs liveness and results; the staking wallet key never touches the machine. init prints the node key hash to register with.

    $ parallelix-node init --wallet 0x...
  4. 03

    Stake and register on-chain

    In the Console, connect the staking wallet and call registerNode with at least 50,000 $PRLX per node and the node key hash from init. Permissionless (no allowlist), no slashing: the principal is returned in full after a 7-day cooldown. The call returns a nodeId.

    // Console · registerNode(stake, tier, nodeKeyHash) -> nodeId
  5. 04

    Start the daemon

    parallelix-node start attaches the machine to the on-chain nodeId, submits the signed capability manifest (GPU model, VRAM, CPU cores, region, supported workload classes), sends liveness heartbeats, and serves dispatched inference requests. Use --gpu or --cpu for the run mode.

    $ parallelix-node start --node-id 4217 --gpu
  6. 05

    Active and earning

    Once heartbeating, the node is active and accrues from the live per-second reward stream while it stays online, weighted stake x tier. Idle (staked but offline) earns nothing.

    $ parallelix-node status

Note·Staking on NodeRegistryLocker

NodeRegistryLocker is live from launch and permissionless. registerNode enforces a minimum 50,000 $PRLX per-node stake (variable above the floor), one stake per node, unlimited nodes per wallet. Principal is returned in full after the 7-day cooldown; there is no slashing.

// Where to go next · reading path