Helix
Trustless AI Training, Unbreakable Security
About
The problem it solves Decentralized AI training today forces a choice: trust hardware that keeps getting broken (AMD disclosed a critical confidential VM vulnerability just last month), or run zero-knowledge proofs on every training step at 100-1000x overhead, making real training impractical. HELIX eliminates this tradeoff. Using multi-party computation with SPDZ information-theoretic MACs, multiple workers collaboratively train a model where no single party ever sees the weights. Security isn't based on hardware trust or computational hardness it's mathematical impossibility. A cheating worker has a 1 in 2^254 chance of evading detection. Who uses this and why: Hedge funds training proprietary trading models on decentralized compute without exposing their alpha Pharmaceutical companies collaborating on drug discovery models without sharing IP Any institution that needs to leverage distributed GPU resources while maintaining absolute certainty their model weights stay private With even one trusted party in the worker set, the remaining shares reveal mathematically zero information about the model. Institutions can use the entire decentralized network with total confidence. Trained models mint as NFTs on ADI Chain with built-in commission — model owners earn revenue every time someone runs inference. Models become tokenized, revenue-generating digital assets that can be bought, sold, and transferred on-chain. Use of AI tools and agents HELIX is itself an AI infrastructure protocol - it enables trustless distributed machine learning training and inference using multi-party computation. The trained models are tokenized as NFTs on ADI Chain, and other users can run AI inference on them through the marketplace, with results attested on-chain via multi-party signatures. The system provides a complete pipeline for decentralized AI model training, ownership, monetization, and inference.
How it's made
Challenges we ran into The biggest challenge was implementing MPC primitives from scratch in Rust - there are almost no production-ready libraries for SPDZ MAC generation, Beaver triple distribution via oblivious transfer, or garbled circuit ReLU over secret-shared values. Every primitive in helix-mpc (37 modules) had to be built, tested, and debugged independently before they could compose into a full training pipeline. Getting Beaver triple generation right was particularly brutal. The MASCOT-style protocol requires coordinated oblivious transfer across all parties, and a subtle off-by-one in the correlation function silently produced incorrect multiplication results that only surfaced as diverging loss curves 50+ training steps later. Tracking that down required building custom diagnostic tooling to dump and compare intermediate share values across workers. Garbled circuit ReLU was another major hurdle - the x25519 oblivious transfer for label transfer needed careful constant-time implementation to avoid timing side channels, and debugging garbled circuits is inherently painful because the intermediate values are encrypted by design. On the smart contract side, getting multi-party attestation verification gas-efficient enough for frequent checkpoints required multiple iterations of the signature batching logic in HelixCoordinatorV4. Early versions cost 300K+ gas per checkpoint; the final implementation gets it down to 50-80K through optimized ECDSA recovery and calldata packing. The end-to-end integration - connecting the Rust MPC engine to on-chain settlement to the Next.js dashboard via WebSocket streaming - had dozens of subtle race conditions around checkpoint timing and worker synchronization that only appeared under real concurrent execution.