Skip to main content
This walks through joining Pinaivu’s live testnet as a node operator: your machine runs the inference (via Ollama), connects to the coordinator’s libp2p mesh, bids on requests, and serves real traffic end-to-end through the production infra — auction, dispatch, settlement, the whole path. This is different from the smoke test: that guide verifies one specific settlement as an internal check. This guide is for anyone who wants to contribute compute and watch their own node pick up and answer real requests.

​
Prerequisites

The current testnet coordinator:
This address will change if the coordinator redeploys to new infrastructure — if it stops responding, check back here for an updated value, or confirm liveness with the health check below before reporting an issue.

​
Step 1 — confirm the coordinator is live

A real response looks like this:
A non-null enclave_object_id means this coordinator instance has already registered its attested key on Sui — you can look that object up on-chain and compare its PCRs against what /get_attestation reports below.

​
Step 2 — get the coordinator’s current peer_id

The coordinator’s enclave generates a fresh keypair on every deploy, so the peer_id rotates each time it redeploys. Always fetch it live rather than hardcoding a value you saw once — a stale peer_id won’t dial through.

​
Step 3 — build the node

If you already have a checkout, rebuild before connecting — the node shares its wire protocol with the coordinator, and an out-of-date binary will fail to dial with a protocol negotiation error.

​
Step 4 — run your node against the testnet coordinator

Pass --payout-address with a Sui testnet address you control — this is how the network pays you for the requests your node serves. Without it, your node still bids and serves requests, but there’s nowhere for settlement to send your share. INSECURE_COORDINATOR=1 tells the node to accept the coordinator’s self-signed TLS certificate (the cert is bound to the enclave’s attested key, not a public CA — that’s expected for testnet). Watch the logs for connection established peer=<coordinator_peer_id> to confirm the mesh handshake succeeded.

​
Step 5 — confirm requests are landing on your node

Send a test request through the coordinator the same way any client would. Inference is dispatched to the winning node over libp2p directly — the coordinator waits for the node’s signed completion and returns the final answer in one response, so there’s no separate request to your node’s HTTP port:
If your node won the auction, your node’s own logs will show the full round trip:
If you don’t win every time, that’s expected — other nodes are bidding on the same mesh, and the auction picks based on price, latency, and reputation.

​
Running multiple local LLMs

Nothing stops you from joining the mesh with more than one backend at once. Each node instance is just a separate process with its own listen port and its own model — run as many as you have local capacity for:
Each instance needs its own --identity-file (defaults to ~/.pinaivu-node/identity.key, so give each one a distinct path) and bids independently. The coordinator’s auction doesn’t know or care that both are running on the same host — from its side they’re just two more peers in the mesh, each capable of winning different requests based on price, latency, and reputation. This is the simplest way to add capacity to the network without provisioning a second machine.