OmniNode shards a model by transformer block and runs it pipeline-parallel over a QUIC mesh. Each result is verifier-signed and settled on SUM Chain — no GPU cluster, no central model host.
Off-chain nodes do the compute; the chain settles the proof. A request is sharded across the mesh, model weights are fetched by content address, and a verifier attests to the result on SUM Chain.
A client submits a prompt and pays a Koppa fee.
The entry node fetches model shards from SNIP storage by content address. merkle_root
Node A runs the embedding and its layer slice, then streams the hidden state to Node B. /omni/tensor-xfer
Node B finishes the layers and lm_head, decodes a token, and returns it — the autoregressive ping-pong. token_id
A verifier signs the result and submits an InferenceAttestation to SUM Chain. InferenceAttestation
The chain records the attestation, settles escrow, and the verified response returns to the client.
Compute and storage run today. Settlement is live on SUM Chain mainnet. Zero-knowledge proofs are real but deliberately staged — each mechanism carries its true status.
Pipeline parallelism shards model layers across devices, routing hidden-state tensors over a low-latency P2P mesh on pure QUIC.
Consumer devices pool their unified memory to run models no single device could hold.
GGUF weights are chunked by transformer block, content-addressed (BLAKE3 → CIDv1), and moved over a 64 MiB sliding-window protocol.
No central model host. Weights are deduplicated and retrievable from SNIP.
Halo2 zero-knowledge proofs of fixed-point inference are byte-deterministic and drift-checked — verified off-chain today.
No trusted setup. Deliberately not yet a mainnet-eligibility signal; on-chain zk verification is future work.
A verifier signs each result and submits an InferenceAttestation; escrow-funded settlement pays out on SUM Chain, deduplicated per session and verifier.
Live on mainnet. No bond slashing in v1 — reward denial, claim withholding, escrow refund; disputes by validator quorum.
On unified-memory hardware, a shard travels from disk to the GPU without a single copy. The mmap the operating system makes is the same memory Metal computes on.
A Rust workspace, edition 2024. Networking and storage sit at the base; a zero-copy bridge and pipeline coordinator sit above; the proof, chain, and operator surfaces sit at the top.
Protocol & operator surface
omni-zkmlProof-artifact substrate, verifier attestation envelope, and the chain-client abstraction.
omni-sumchainSUM Chain JSON-RPC adapter — attestation submit + settlement read / claim / dispute.
omni-contributorOff-chain contributor inference node — jobs, sessions, integrity-evidence chains.
omni-nodeThe operator CLI binary — listen, shard, fetch, verify-proof, settlement.
omni-proofs-halo2-reference4→8→4 int16 Halo2 reference proof (halo2-mlp-v1).
omni-proofs-halo2-production-mlp16→32→16→8 int16 Halo2 production proof (production-fixedpoint-mlp-v1).
Bridge & coordination
omni-bridgePyO3 native extension — zero-copy shard access exposed to NumPy / MLX.
omni-pipelinePipeline-parallel coordination — GPipe scheduling, hidden-state tensor transport.
Networking & storage
omni-netP2P mesh on libp2p 0.55 — QUIC, mDNS discovery, Gossipsub, shard & tensor request-response.
omni-storeZero-copy GGUF parsing, layer-wise chunking, BLAKE3 → CIDv1 addressing, SNIP V2 store.
Shared foundation
omni-typesShared types, errors, config, and the Phase-5 attestation / commitment types.
Two layers are easy to conflate. Verifier attestations settle escrow on SUM Chain today. The zero-knowledge proof path is real and byte-deterministic — but deliberately not yet a mainnet-eligibility signal.
production-fixedpoint-mlp-v1
Halo2 over the Pasta curves, IPA, no trusted setup. Proofs are byte-identical across hosts; the verifier re-derives circuit and verifying-key identity and refuses to load on any drift.
Settlement — live on SUM Chain mainnet
zkML proofs — code-backed, deliberately dormant
Phase 4 runs real autoregressive inference across a LAN: one machine holds the embedding and first layers, the other holds the rest and the lm_head, and a hidden-state tensor ping-pongs between them over QUIC.
Browse the exact content-addressed shard-set — by merkle_root — that the network serves from SNIP storage.
Machine Aembed_tokens — token embeddinglayers[0:N/2] — first half of the transformerKV cache — independent, synced by orderMachine Blayers[N/2:] — second halfnorm + lm_head — final projectionargmax — greedy decodingWire discriminator: hidden_dim == model_size→ activation tensor · hidden_dim == 1 → token id
# Prerequisites
pip install mlx mlx-lm transformers rich
# Machine A — sender: embed + first half of the layers
python showcase_tui.py sender /path/to/model.gguf
# Machine B — receiver: second half + norm + lm_head
python showcase_tui.py receiver /path/to/model.ggufRecent, dated milestones from the OmniNode-Protocol repository.
Audited the public posture: verifier attestations and escrow settlement are live on SUM Chain mainnet; Halo2 zkML proofs verify off-chain and are deliberately not yet a mainnet-eligibility signal. The site now states both precisely.
Chain-authoritative OpenDispute (funder-signed) and ResolveDispute (validator-quorum over a basis-point threshold of the active PoA set). No personal resolver key; non-signing validators still count in the denominator.
A verifier submits its own ClaimReward against the InferenceAttestation it holds. No coordinator-claim and no claim-on-behalf — self-claim only, enforced on-chain.
The node is open source and builds with a stable Rust toolchain (edition 2024, MSRV 1.85). Default builds pull zero chain and zero proof dependencies.
cargo build -p omni-node --releaseChunk a model by transformer block and content-address it (BLAKE3 → CIDv1) into the local SNIP store.
target/release/omni-node shard ./model.ggufJoin the mesh over QUIC with mDNS discovery. Opt into more surface with cargo features: --features submit (attestation submit), settlement-read, settlement-submit, settlement-dispute.
target/release/omni-node listenOmniNode is open source under MIT / Apache-2.0 — built in the open, from the bottom up.