>ParalleliX AI Lifecycle

// Execution plane · 04 → 063 steps

1. // 04

   Dispatch

   The whole inference request, or a single sub-task on the general path, is encrypted to the assigned node's RSA public key before transmission. Only that node can decrypt the payload it was given. In-transit confidentiality is a default, not an option, and dispatch is point-to-point, not broadcast.

   • ·Asymmetric envelope per node: coordinator encrypts to node.pub, never holds plaintext mid-transit.
   • ·Dispatch is point-to-point; no node sees another node's payload.

   coordinator // dispatch

   > encrypt req_a3f1 → nd_4f7c (RSA to node.pub)> encrypt req_a3f2 → nd_9b2a (RSA to node.pub)> 142 / 142 encrypted and dispatched

2. // 05

   Execute

   The node decrypts the payload and runs it on local hardware. An inference request runs whole: the node generates the full autoregressive output. Execution time is bounded by the node's declared capacity and the deadline. If the node does not return within the deadline, the work is re-dispatched to a fresh node and the original return is discarded. The deadline timer starts at decrypt, not at dispatch.

   • ·Deadline timer starts at decrypt, not at dispatch.
   • ·Timeout on execute triggers re-dispatch to a fresh node; original result is discarded.
   • ·The execute step is the only slow step. All other hot-path stages are bounded by RSA verification cost.

   node // execute

   > decrypt req_a3f1 · class ai-inference> exec cuda · autoregressive decode · model oss-chat-v1> done · t=41ms> returning result + PoE commitment

3. // 06

   Proof-of-Execution

   The node computes a SHA-256 commitment over the result and signs it. This binds a specific node to a specific result for a specific task. It is not a zero-knowledge proof. Honesty is enforced by sampled re-dispatch (step 07), not by the hash alone. Real zero-knowledge proofs are a research direction, not a current capability.

   • ·PoE = SHA-256(task_id || result || node_id), RSA-signed by the node.
   • ·poe.v1 is the launch commitment scheme. Future schemes ship as poe.v2.
   • ·Proves a specific node returned a specific result. Does not prove the computation was correct.

   node // poe · illustrative pseudocode

   def proof_of_execution(task_id, result, node_id):    return sha256(task_id + result + node_id).digest()# poe: e7b25a91ff2c9a3f41ce6f027a2cb194# signed: rsa_sign(node.key, result || poe)

// Coordination plane · 07 → 093 steps

1. // 07

   Validate

   The coordination layer runs two checks before settlement. First: reconstruct SHA-256(request_id, result, node_id) and compare it to what the node submitted. Mismatches reject outright. Second: a configurable fraction of completed units, whole inference requests or general-path sub-tasks, is re-dispatched to a second, independently selected node, and the two results are compared. Disagreement triggers a third dispatch and a majority decision.

   • ·Hash-commitment check: reconstruct SHA-256(request_id, result, node_id), compare. Mismatch = reject.
   • ·Sampled redundant re-dispatch: a second node re-runs the same unit; results compared.
   • ·Disagreement triggers a third dispatch and majority decision. Persistent disagreement flags all parties.
   • ·Rejected results are dropped and the node flagged; repeated rejection removes the node from the pool.

   coordinator // validate

   > hash check: ok (SHA-256 reconstructed, matched)> redundant sample: 14 / 142 re-dispatched> all samples agree> 142 / 142 validated · settling

2. // 08

   Aggregate

   General-path only. A whole inference request has a single result and skips this step: its output returns directly to ParalleliX AI through the same encrypted channel. For parallelizable workloads, validated sub-task results are aggregated by the coordinator into the task's final output, honouring the original dependency graph (ordering, joins, reductions). The return channel is encrypted to the requester's public key.

   • ·AI inference: single result, no aggregation. The output returns whole to ParalleliX AI.
   • ·Parallelizable workloads: aggregation honours the original dependency graph: order, joins, reductions.
   • ·Return channel is end-to-end encrypted to the requester's pubkey.
   • ·Settlement record is anchored to the chain after the result is finalised.

   coordinator // aggregate (general path)

   > stitching 142 / 142 sub-task results> dependency graph resolved> result ready · encrypting for requester

3. // 09

   Settle / stream rewards

   Operators are paid for staying online, not per request. Serving work keeps a node online, and an online node accrues from the live per-second reward stream weighted by stake × tier. During the bootstrap period, the stream sources from the 25% Operator Rewards bucket, fed via Sablier. In steady state, it sources from a share of ParalleliX AI usage payments, split 85% operators / 10% treasury / 5% infra, settled in $PRLX.

   • ·Bootstrap period: rewards funded from the 25% Operator Rewards allocation (~34,200 $PRLX/day over ~24 months).
   • ·Steady state: a share of ParalleliX AI usage payments, split 85% operators / 10% treasury / 5% infra.
   • ·The 4% transfer tax does NOT fund operator rewards at any point.
   • ·Execution record anchors on-chain in batches: at launch, one commitment per ~10 minutes.

   coordinator // settle

   > streaming to 38 online nodes> source: bootstrap subsidy (25% bucket)> earned · nd_4f7c: 39.79 $PRLX (streaming)> execution record anchored · batch committed