Pinaivu AI grounds every guarantee in Ed25519 signatures and SHA-256 Merkle proofs — not a coordinator, not a token. Settlement, storage and anchoring are pluggable. Swap a TOML value, not your stack.
For every turn (P, C, R), today's provider observes all three, sets price ρ unilaterally, and revokes access at will. None of this is forced by the maths — only by the architecture.
Every prompt, every accumulated context, every response flows through one party. Pinaivu AI keeps the full session `C` encrypted under a client-held key `K`; the GPU node sees only the decrypted context window for the current turn.
Bittensor collapses without TAO. Every prior decentralised inference system grounds trust in a specific chain, token and validator set. Pinaivu AI's trust model is self-sufficient; any chain is an optional settlement adapter selected in a TOML file.
Batch marketplaces (io.net, Akash) and routers (Fortytwo) can't prove node N ran job J at the claimed parameters. Pinaivu AI ships every response with a self-verifiable ProofOfInference — Ed25519-signed, offline checkable, binding on (model, tokens, Δ, H_in, H_out).
Layers interact only through trait interfaces. Layer 0 (Crypto) has no external deps. Every layer above it may use external infra, but none is required.
TypeScript SDK, drop-in HTTP API, Web UI. Change the base URL; keep your code. Streaming, sessions and proof retrieval are native.
Full history `C` is AES-256-GCM encrypted under a client-held `K`. The GPU node decrypts only the active context window — never `C`, never `K`.
Every node keeps a Merkle tree of its signed proofs. The root is broadcast over libp2p gossipsub every 10 min. Chain anchoring is optional.
Client broadcasts request; nodes pass six cheap-to-expensive checks and submit a bid. Composite score (0.4×price + 0.3×latency + 0.3×rep) picks the winner.
Five adapters: free, signed-receipt, off-chain channel, Sui, EVM. Pick in TOML; same binary. Payment channels amortise gas 50× over 100 requests.
Three-method interface: put/get/delete. Local, IPFS, Walrus, Memory — same protocol. SHA-256 IDs mean put(b)=put(b) deduplicates for free.
Four stages. Each one cryptographically verifiable — from the sealed-bid auction through Ed25519-signed proof delivery.
Client broadcasts an InferenceRequest on the gossipsub topic for the required model, carrying model ID, budget, and privacy level — not the context (that stays client-side until a winner is chosen).
GPU nodes pass six checks (model, capacity, queue, budget, privacy, throttle) and submit bids. Client picks winner by composite score: 0.4×price + 0.3×latency + 0.3×reputation.
Client encrypts the context window W for the winning node via X25519 DH and sends it directly to that node's API. Node decrypts W in RAM, runs inference, streams tokens back, then zeroes W.
Node signs ProofOfInference π binding (model, tokens, Δ, H_in, H_out) with Ed25519. π is appended to the node's Merkle tree. Settlement adapter executes and ships π to the client.
Every open-weight checkpoint that fits in VRAM. Pre-cached for the popular ones, on-demand for the rest.
The largest open LLM running on the network. Sharded across 16 consumer GPUs via tensor parallel. Competitive with GPT-4 on most benchmarks at a fraction of the cost.
State-of-the-art text-to-image at 1024² native resolution. Runs on a single consumer GPU. 4-step Turbo variant generates in under 1 second per image.
99-language speech-to-text with automatic language detection. Runs 52× realtime on an RTX 3090. Native WebSocket streaming for voice applications.
Every prior system either lacks G2 (no verifiable accountability) or sacrifices G3/G4 (hard-coded chain and storage). Pinaivu AI is the first to satisfy all five guarantees simultaneously.
No reinvention for its own sake. Every layer is a battle-tested open-source component, assembled specifically for GPU compute coordination.
TCP + QUIC dual-stack with Noise authenticated encryption and Yamux stream multiplexing. AutoNAT traversal means any home node can participate without port-forwarding.
Kademlia DHT for peer routing and mDNS for local discovery. Five gossipsub topics carry inference requests, bids, announcements and Merkle root broadcasts.
Every node is an Ed25519 keypair. The libp2p PeerId is derived from pk_N — no separate account or wallet needed. 128-bit security per RFC 8032.
A signed execution receipt bound to (model, tokens, latency, H_in, H_out). Verifiable offline with only the node's public key. Constant-time O(1) verification, no network call.
Session context encrypted under a client-held key K derived from X25519 DH. The GPU node never sees K — only the current-turn context window, zeroed from RAM after inference.
Five adapters behind one interface: free, signed-receipt, off-chain payment channel, Sui (Phase D), EVM (Phase E). All selected by a single TOML key — same binary, zero code changes.
A live breakdown of the hardware running inference right now. Consumer cards dominate the network — by design.
Four phases. Shipping cadence tied to node-count milestones, not marketing dates.
No credit card. No token. No permission. Phase C is live — Ed25519 identity, Merkle reputation and signed-receipt settlement work today, with zero blockchain required.